Merge lp:~mir-team/mir/v0.1.2 into lp:mir/0.1

[kevin gunn]

Merge v0.1.2 from development-branch r1248

    - graphics: android: improve interface for mga::DisplayDevice so its
      just concerned with rendering and posting.
    - surfaces: rename "surfaces" component to "scene".
    - surfaces, shell: Migrate Session data model from shell to surfaces.
    - graphics: change fill_ipc_package() to use real pointers.
    - mir_client_library.h: Fix typo "do and locking" should be "do any
      locking".
    - API enumerations cleanup: Remove slightly misleading *_enum_max_
      values, and replace them with more accurate plural forms.
    - test_android_communication_package: Do not expect opened fd to be >0,
      we may have closed stdin making this a valid value (LP: #1247718).
    - Update docs about running Mir on the desktop to mention new package
      ubuntu-desktop-mir.
    - offscreen: Add a display that renders its output to offscreen buffers
    - graphics: android: fix regression for hwc1.0 devices introduced in r1228
      (LP: #1252433).
    - OffscreenPlatform provides the services that the offscreen display
      needs from the Platform.
    - graphics: android: consolidate the GLContexts classes in use.
    - Fix uninitialized variable causing random drm_auth_magic test
      failures. (LP: #1252144).
    - Add a fullyish functional Udev wrapper. This currently sits in
      graphics/gbm, but will be moved to the top-level when input device
      detection migrates.
    - Add resizing support to example code; demo-shell and clients.
    - eglapp: Clarify messages about pixel formats (LP: #1168304).
    - Adds support to the MirMotionEvent under pointer_coordinates called
      tool_type. This will allow clients to tell what type of tool is
      being used, from mouse/finger/etc. (LP: #1252498)
    - client,frontend: Report the real available surface pixel formats to
      clients. (LP: #1240833)
    - graphics: android: 1) change hwc1.1 to make use of sync fences during
      the compositor's gl renderloop. Note that we no longer wait for the
      render to complete, we pass this responsibility to the driver and the
      kernel. 2) support nexus 10. (LP: #1252173) (LP: #1203268)
    - shell: don't publish SurfacesContainer - it can be private to shell.
    - gbm: Don't mess up the VT mode on setup failure Only restore the
      previous VT mode during shutdown if it was VT_AUTO.
    - Fix a crash due to a failed eglMakeCurrent() call when in nested mode.
    - shell: unity-mir uses shell::FocusSetter - make the header public again
    - Add resize support to client surfaces (mir::client::MirSurface).
    - graphics: android: support 'old aka 2012' nexus 7 hwc (nvidia tegra3
      SoC) better. (LP: #1231917)
    - Add resize support to *ClientBuffer classes. Now always get dimensions
      from the latest buffer package.
    - android: support driver hooks for the Mali T604 (present in nexus 10)
    - Add width and height to the protocol Buffer messages, in preparation
      for resizable surfaces.
    - surfaces, shell, logging, tests: don't publish headers
      that can be private to surfaces. surfaces/basic_surface.h,
      surfaces/surface_controller.h and shell/surface_builder.h
    - examples: Restore GL framebuffer binding when destroying the render
      target
    - examples, surfaces, shell: remove render_surfaces dependency on
      BasicSurface
    - geometry: remove implementation of streaming operators from headers
      (LP: #1247820)
    - Eliminate the registration order focus sequence, folding it's
      functionality in to the session container.
    - Ensure the session mediator releases acquired buffer resources before
      attempting to acquire a new buffer on behalf of the client. This fixes
      performance regression (LP: #1249210).
    - Some cleanups to test_client_input.cpp.
    - Factor out a bunch of "ClientConfigCommon".
    - Small cleanup to session container test to increase encapsulation.
    - shell, surfaces: Another step in "fixing" the surfaces hierarchies -
      only publish interfaces and putting the data model into surfaces.
    - graphics: android: HWC1.1 use EGL to get further information about
      the framebuffer pixel format.
    - Fix FTBS using use_debflags=ON (building for android-armhf).
      (LP: #1248014)
    - Add a client input receiver report.
    - doc: doxygen 1.8.4 complains about an obsolete config so ran "doxygen
      u Doxyfile.in".
    - Implement resize() for the server-side Surface classes.
    - android: clean up mga::DisplayBuffer and mga::DisplayBufferFactory
    - Add resize() support to BufferStream, in preparation for resizable
      surfaces.
    - Merge metadata changes from the newly reconstructed lp:mir
    - tests: Deduplicate mg::GraphicBufferAllocator stubs.
    - examples: Remove spurious use of mir/shell/surface.h.
    - frontend: remove ClientTrackingSurface from the Surface class
      hierarchy
    - Bumping ABI on server to libmirserver11.
    - Don't mention "Renderable". That interface hasn't existed for quite
      some time now.
    - android-input: Assign more unique touch ids

[Kevin DuBois (kdub)]

looks okay to me

review: Approve

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:1249
http://jenkins.qa.ubuntu.com/job/mir-ci/1619/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-android-trusty-i386-build/268
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-clang-trusty-amd64-build/265
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-trusty-amd64-ci/17
        deb: http://jenkins.qa.ubuntu.com/job/mir-trusty-amd64-ci/17/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-trusty-armhf-ci/17
        deb: http://jenkins.qa.ubuntu.com/job/mir-trusty-armhf-ci/17/artifact/work/output/*zip*/output.zip

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/mir-ci/1619/rebuild

review: Approve (continuous-integration)

[Robert Carr (robertcarr)]

+1

review: Approve

[Daniel van Vugt (vanvugt)]

The debian/changelog is missing stuff that is correctly mentioned in the commit message. Also, we need to use the official format "(LP: #NNNNNNN)" to keep the automation accurate.

review: Needs Fixing

[Daniel van Vugt (vanvugt)]

review: Approve

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:1250
http://jenkins.qa.ubuntu.com/job/mir-ci/1620/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-android-trusty-i386-build/276
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-clang-trusty-amd64-build/273
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-trusty-amd64-ci/18
        deb: http://jenkins.qa.ubuntu.com/job/mir-trusty-amd64-ci/18/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-trusty-armhf-ci/18
        deb: http://jenkins.qa.ubuntu.com/job/mir-trusty-armhf-ci/18/artifact/work/output/*zip*/output.zip

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/mir-ci/1620/rebuild

review: Approve (continuous-integration)

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:1251
http://jenkins.qa.ubuntu.com/job/mir-ci/1621/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-android-trusty-i386-build/277
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-clang-trusty-amd64-build/274
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-trusty-amd64-ci/19
        deb: http://jenkins.qa.ubuntu.com/job/mir-trusty-amd64-ci/19/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-trusty-armhf-ci/19
        deb: http://jenkins.qa.ubuntu.com/job/mir-trusty-armhf-ci/19/artifact/work/output/*zip*/output.zip

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/mir-ci/1621/rebuild

review: Approve (continuous-integration)

=== modified file '3rd_party/android-input/android/CMakeLists.txt'
--- 3rd_party/android-input/android/CMakeLists.txt	2013-10-15 08:53:10 +0000
+++ 3rd_party/android-input/android/CMakeLists.txt	2013-11-25 03:07:43 +0000
@@ -33,6 +33,7 @@
   frameworks/base/services/input/InputReader.cpp
   frameworks/base/services/input/InputTransport.cpp
   frameworks/base/services/input/InputWindow.cpp
+  frameworks/base/services/input/IntSet.cpp
   frameworks/base/services/input/PointerController.cpp
   # Keyboard/keymap handling
   frameworks/base/services/input/GenericKeyMap.cpp

=== modified file '3rd_party/android-input/android/frameworks/base/include/androidfw/Input.h'
--- 3rd_party/android-input/android/frameworks/base/include/androidfw/Input.h	2013-05-03 16:38:07 +0000
+++ 3rd_party/android-input/android/frameworks/base/include/androidfw/Input.h	2013-11-25 03:07:43 +0000
@@ -77,9 +77,12 @@
 /*
  * Maximum pointer id value supported in a motion event.
  * Smallest pointer id is 0.
- * (This is limited by our use of BitSet32 to track pointer assignments.)
+ * Any reasonably large value that fits in a int32_t is fine.
+ * A "reasonably large" number is one that guarantees uniqueness of a touch id for some 30 seconds
+ * after its corresponding touch point has physically ended, under very heavy usage (many
+ * simultaneous taps ongoing).
  */
-#define MAX_POINTER_ID 31
+#define MAX_POINTER_ID 100000000
 
 /*
  * Declare a concrete type for the NDK's input event forward declaration.

=== modified file '3rd_party/android-input/android/frameworks/base/include/androidfw/InputTransport.h'
--- 3rd_party/android-input/android/frameworks/base/include/androidfw/InputTransport.h	2013-05-31 16:06:07 +0000
+++ 3rd_party/android-input/android/frameworks/base/include/androidfw/InputTransport.h	2013-11-25 03:07:43 +0000
@@ -29,12 +29,15 @@
  */
 
 #include <androidfw/Input.h>
+#include <androidfw/IntSet.h>
 #include <std/Errors.h>
 #include <std/Timers.h>
 #include <std/RefBase.h>
 #include <std/String8.h>
 #include <std/Vector.h>
-#include <std/BitSet.h>
+
+// C++ std lib
+#include <unordered_map>
 
 namespace android {
 
@@ -352,23 +355,23 @@
     // Touch state per device and source, only for sources of class pointer.
     struct History {
         nsecs_t eventTime;
-        BitSet32 idBits;
-        int32_t idToIndex[MAX_POINTER_ID + 1];
+        IntSet ids;
+        std::unordered_map<int32_t, size_t> idToIndex;
         PointerCoords pointers[MAX_POINTERS];
 
         void initializeFrom(const InputMessage* msg) {
             eventTime = msg->body.motion.eventTime;
-            idBits.clear();
+            ids.clear();
             for (size_t i = 0; i < msg->body.motion.pointerCount; i++) {
                 uint32_t id = msg->body.motion.pointers[i].properties.id;
-                idBits.markBit(id);
+                ids.insert(id);
                 idToIndex[id] = i;
                 pointers[i].copyFrom(msg->body.motion.pointers[i].coords);
             }
         }
 
         const PointerCoords& getPointerById(uint32_t id) const {
-            return pointers[idToIndex[id]];
+            return pointers[idToIndex.at(id)];
         }
     };
     struct TouchState {
@@ -385,7 +388,7 @@
             historyCurrent = 0;
             historySize = 0;
             lastResample.eventTime = 0;
-            lastResample.idBits.clear();
+            lastResample.ids.clear();
         }
 
         void addHistory(const InputMessage* msg) {

=== added file '3rd_party/android-input/android/frameworks/base/include/androidfw/IntSet.h'
--- 3rd_party/android-input/android/frameworks/base/include/androidfw/IntSet.h	1970-01-01 00:00:00 +0000
+++ 3rd_party/android-input/android/frameworks/base/include/androidfw/IntSet.h	2013-11-25 03:07:43 +0000
@@ -0,0 +1,104 @@
+/*
+ * Copyright © 2013 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License version 3,
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Author: Daniel d'Andrada <[e-mail]>
+ */
+
+#ifndef ANDROID_INTSET_H
+#define ANDROID_INTSET_H
+
+#include <assert.h>
+
+// C++ std lib
+#include <algorithm>
+#include <sstream>
+#include <set>
+
+#ifdef ANDROID_INPUT_INTSET_TEST
+namespace test {
+#endif
+
+namespace android {
+
+/*
+  A set of integers
+
+  It serves two purposes:
+   - Provide a convenience wrapper for std::set<int32_t>. Because the std API is cumbersome.
+   - Provide an API similar to the BitSet32 class that it's replacing.
+ */
+class IntSet {
+public:
+
+#ifdef ANDROID_INPUT_INTSET_TEST
+    static int constructionCount;
+    static int destructionCount;
+#endif
+
+    IntSet();
+    IntSet(std::initializer_list<int32_t> list);
+    virtual ~IntSet();
+
+    IntSet operator -(const IntSet &other) const;
+    IntSet operator &(const IntSet &other) const;
+    bool operator ==(const IntSet &other) const;
+
+    std::set<int32_t>::iterator begin() { return stdSet.begin(); }
+    std::set<int32_t>::const_iterator begin() const { return stdSet.begin(); }
+    std::set<int32_t>::iterator end() { return stdSet.end(); }
+    std::set<int32_t>::const_iterator end() const { return stdSet.end(); }
+    std::set<int32_t>::const_iterator cbegin() const { return stdSet.cbegin(); }
+    std::set<int32_t>::const_iterator cend() const { return stdSet.cend(); }
+
+    void clear() { stdSet.clear(); }
+    void insert(int32_t value) { stdSet.insert(value); }
+
+    template<typename Func>
+    void forEach(Func func) { std::for_each(stdSet.begin(), stdSet.end(), func); }
+
+    template<typename Func>
+    void forEach(Func func) const { std::for_each(stdSet.begin(), stdSet.end(), func); }
+
+    void remove(int32_t value) { stdSet.erase(value); }
+    void remove(const IntSet &values);
+
+    size_t size() const { return stdSet.size(); }
+    size_t count() const { return stdSet.size(); }
+
+    bool isEmpty() const { return stdSet.empty(); }
+
+    bool contains(int32_t value) const;
+
+    int32_t first() const { return *stdSet.cbegin(); }
+
+    // It's assumed that the given value does exist in the set
+    size_t indexOf(int32_t value) const;
+
+    std::string toString() const;
+
+private:
+    void remove(std::set<int32_t>::iterator selfIterator,
+                std::set<int32_t>::const_iterator otherIterator,
+                std::set<int32_t>::const_iterator otherEnd);
+    std::set<int32_t> stdSet;
+};
+
+} // namespace android
+
+#ifdef ANDROID_INPUT_INTSET_TEST
+} // namespace test
+#endif
+
+#endif

=== modified file '3rd_party/android-input/android/frameworks/base/include/androidfw/VelocityControl.h'
--- 3rd_party/android-input/android/frameworks/base/include/androidfw/VelocityControl.h	2013-05-03 16:38:07 +0000
+++ 3rd_party/android-input/android/frameworks/base/include/androidfw/VelocityControl.h	2013-11-25 03:07:43 +0000
@@ -19,6 +19,7 @@
 
 
 #include <androidfw/Input.h>
+#include <androidfw/IntSet.h>
 #include <androidfw/VelocityTracker.h>
 #include <std/Timers.h>
 
@@ -101,6 +102,7 @@
     nsecs_t mLastMovementTime;
     VelocityTracker::Position mRawPosition;
     VelocityTracker mVelocityTracker;
+    IntSet mIds;
 };
 
 } // namespace android

=== modified file '3rd_party/android-input/android/frameworks/base/include/androidfw/VelocityTracker.h'
--- 3rd_party/android-input/android/frameworks/base/include/androidfw/VelocityTracker.h	2013-05-03 16:38:07 +0000
+++ 3rd_party/android-input/android/frameworks/base/include/androidfw/VelocityTracker.h	2013-11-25 03:07:43 +0000
@@ -17,10 +17,12 @@
 #ifndef _ANDROIDFW_VELOCITY_TRACKER_H
 #define _ANDROIDFW_VELOCITY_TRACKER_H
 
-
 #include <androidfw/Input.h>
+#include <androidfw/IntSet.h>
 #include <std/Timers.h>
-#include <std/BitSet.h>
+
+// C++ std lib
+#include <unordered_map>
 
 namespace android {
 
@@ -74,14 +76,14 @@
     // Resets the velocity tracker state for specific pointers.
     // Call this method when some pointers have changed and may be reusing
     // an id that was assigned to a different pointer earlier.
-    void clearPointers(BitSet32 idBits);
+    void clearPointers(const IntSet &ids);
 
     // Adds movement information for a set of pointers.
-    // The idBits bitfield specifies the pointer ids of the pointers whose positions
+    // The ids set specifies the pointer ids of the pointers whose positions
     // are included in the movement.
     // The positions array contains position information for each pointer in order by
-    // increasing id.  Its size should be equal to the number of one bits in idBits.
-    void addMovement(nsecs_t eventTime, BitSet32 idBits, const Position* positions);
+    // increasing id.  Its size should be equal to the size of ids.
+    void addMovement(nsecs_t eventTime, const IntSet &ids, const Position* positions);
 
     // Adds movement information for all pointers in a MotionEvent, including historical samples.
     void addMovement(const MotionEvent* event);
@@ -100,13 +102,13 @@
     inline int32_t getActivePointerId() const { return mActivePointerId; }
 
     // Gets a bitset containing all pointer ids from the most recent movement.
-    inline BitSet32 getCurrentPointerIdBits() const { return mCurrentPointerIdBits; }
+    inline const IntSet &getCurrentPointerIds() const { return mCurrentPointerIds; }
 
 private:
     static const char* DEFAULT_STRATEGY;
 
     nsecs_t mLastEventTime;
-    BitSet32 mCurrentPointerIdBits;
+    IntSet mCurrentPointerIds;
     int32_t mActivePointerId;
     VelocityTrackerStrategy* mStrategy;
 
@@ -127,8 +129,8 @@
     virtual ~VelocityTrackerStrategy() { }
 
     virtual void clear() = 0;
-    virtual void clearPointers(BitSet32 idBits) = 0;
-    virtual void addMovement(nsecs_t eventTime, BitSet32 idBits,
+    virtual void clearPointers(const IntSet &ids) = 0;
+    virtual void addMovement(nsecs_t eventTime, const IntSet &ids,
             const VelocityTracker::Position* positions) = 0;
     virtual bool getEstimator(uint32_t id, VelocityTracker::Estimator* outEstimator) const = 0;
 };
@@ -159,8 +161,8 @@
     virtual ~LeastSquaresVelocityTrackerStrategy();
 
     virtual void clear();
-    virtual void clearPointers(BitSet32 idBits);
-    virtual void addMovement(nsecs_t eventTime, BitSet32 idBits,
+    virtual void clearPointers(const IntSet &ids);
+    virtual void addMovement(nsecs_t eventTime, const IntSet &ids,
             const VelocityTracker::Position* positions);
     virtual bool getEstimator(uint32_t id, VelocityTracker::Estimator* outEstimator) const;
 
@@ -175,11 +177,11 @@
 
     struct Movement {
         nsecs_t eventTime;
-        BitSet32 idBits;
+        IntSet ids;
         VelocityTracker::Position positions[MAX_POINTERS];
 
         inline const VelocityTracker::Position& getPosition(uint32_t id) const {
-            return positions[idBits.getIndexOfBit(id)];
+            return positions[ids.indexOf(id)];
         }
     };
 
@@ -202,8 +204,8 @@
     ~IntegratingVelocityTrackerStrategy();
 
     virtual void clear();
-    virtual void clearPointers(BitSet32 idBits);
-    virtual void addMovement(nsecs_t eventTime, BitSet32 idBits,
+    virtual void clearPointers(const IntSet &ids);
+    virtual void addMovement(nsecs_t eventTime, const IntSet &ids,
             const VelocityTracker::Position* positions);
     virtual bool getEstimator(uint32_t id, VelocityTracker::Estimator* outEstimator) const;
 
@@ -218,8 +220,8 @@
     };
 
     const uint32_t mDegree;
-    BitSet32 mPointerIdBits;
-    State mPointerState[MAX_POINTER_ID + 1];
+    IntSet mPointerIds;
+    std::unordered_map<int32_t, State> mPointerState; // maps the id of a pointer to its state
 
     void initState(State& state, nsecs_t eventTime, float xpos, float ypos) const;
     void updateState(State& state, nsecs_t eventTime, float xpos, float ypos) const;
@@ -236,8 +238,8 @@
     virtual ~LegacyVelocityTrackerStrategy();
 
     virtual void clear();
-    virtual void clearPointers(BitSet32 idBits);
-    virtual void addMovement(nsecs_t eventTime, BitSet32 idBits,
+    virtual void clearPointers(const IntSet &ids);
+    virtual void addMovement(nsecs_t eventTime, const IntSet &ids,
             const VelocityTracker::Position* positions);
     virtual bool getEstimator(uint32_t id, VelocityTracker::Estimator* outEstimator) const;
 
@@ -253,11 +255,11 @@
 
     struct Movement {
         nsecs_t eventTime;
-        BitSet32 idBits;
+        IntSet ids;
         VelocityTracker::Position positions[MAX_POINTERS];
 
         inline const VelocityTracker::Position& getPosition(uint32_t id) const {
-            return positions[idBits.getIndexOfBit(id)];
+            return positions[ids.indexOf(id)];
         }
     };
 

=== modified file '3rd_party/android-input/android/frameworks/base/services/input/InputDevice.cpp'
--- 3rd_party/android-input/android/frameworks/base/services/input/InputDevice.cpp	2013-02-05 17:19:57 +0000
+++ 3rd_party/android-input/android/frameworks/base/services/input/InputDevice.cpp	2013-11-25 03:07:43 +0000
@@ -16,6 +16,9 @@
 
 #define LOG_TAG "InputDevice"
 
+#include <cutils/log.h>
+#define DEBUG_PROBE 0
+
 #include <stdlib.h>
 #include <unistd.h>
 #include <ctype.h>
@@ -97,7 +100,7 @@
     path.append("/usr/");
     appendInputDeviceConfigurationFileRelativePath(path, name, type);
 #if DEBUG_PROBE
-    ALOGD("Probing for system provided input device configuration file: path='%s'", path.string());
+    ALOGD("Probing for system provided input device configuration file: path='%s'", path.c_str());
 #endif
     if (!access(c_str(path), R_OK)) {
 #if DEBUG_PROBE
@@ -119,7 +122,7 @@
     path.append("/system/devices/");
     appendInputDeviceConfigurationFileRelativePath(path, name, type);
 #if DEBUG_PROBE
-    ALOGD("Probing for system user input device configuration file: path='%s'", path.string());
+    ALOGD("Probing for system user input device configuration file: path='%s'", path.c_str());
 #endif
     if (!access(c_str(path), R_OK)) {
 #if DEBUG_PROBE
@@ -131,7 +134,7 @@
     // Not found.
 #if DEBUG_PROBE
     ALOGD("Probe failed to find input device configuration file: name='%s', type=%d",
-            name.string(), type);
+            name.c_str(), type);
 #endif
     return String8();
 }

=== modified file '3rd_party/android-input/android/frameworks/base/services/input/InputDispatcher.cpp'
--- 3rd_party/android-input/android/frameworks/base/services/input/InputDispatcher.cpp	2013-08-28 03:41:48 +0000
+++ 3rd_party/android-input/android/frameworks/base/services/input/InputDispatcher.cpp	2013-11-25 03:07:43 +0000
@@ -152,7 +152,7 @@
                 pointerCount, MAX_POINTERS);
         return false;
     }
-    BitSet32 pointerIdBits;
+    IntSet pointerIds;
     for (size_t i = 0; i < pointerCount; i++) {
         int32_t id = pointerProperties[i].id;
         if (id < 0 || id > MAX_POINTER_ID) {
@@ -160,11 +160,11 @@
                     id, MAX_POINTER_ID);
             return false;
         }
-        if (pointerIdBits.hasBit(id)) {
+        if (pointerIds.contains(id)) {
             ALOGE("Motion event has duplicate pointer id %d", id);
             return false;
         }
-        pointerIdBits.markBit(id);
+        pointerIds.insert(id);
     }
     return true;
 }
@@ -1043,7 +1043,7 @@
     // Success!  Output targets.
     injectionResult = INPUT_EVENT_INJECTION_SUCCEEDED;
     addWindowTargetLocked(mFocusedWindowHandle,
-            InputTarget::FLAG_FOREGROUND | InputTarget::FLAG_DISPATCH_AS_IS, BitSet32(0),
+            InputTarget::FLAG_FOREGROUND | InputTarget::FLAG_DISPATCH_AS_IS, IntSet(),
             inputTargets);
 
     // Done.
@@ -1181,7 +1181,7 @@
                     }
 
                     mTempTouchState.addOrUpdateWindow(
-                            windowHandle, outsideTargetFlags, BitSet32(0));
+                            windowHandle, outsideTargetFlags, IntSet());
                 }
             }
         });
@@ -1250,10 +1250,10 @@
         }
 
         // Update the temporary touch state.
-        BitSet32 pointerIds;
+        IntSet pointerIds;
         if (isSplit) {
-            uint32_t pointerId = entry->pointerProperties[pointerIndex].id;
-            pointerIds.markBit(pointerId);
+            int32_t pointerId = entry->pointerProperties[pointerIndex].id;
+            pointerIds.insert(pointerId);
         }
         mTempTouchState.addOrUpdateWindow(newTouchedWindowHandle, targetFlags, pointerIds);
     } else {
@@ -1288,7 +1288,7 @@
 #endif
                 // Make a slippery exit from the old window.
                 mTempTouchState.addOrUpdateWindow(oldTouchedWindowHandle,
-                        InputTarget::FLAG_DISPATCH_AS_SLIPPERY_EXIT, BitSet32(0));
+                        InputTarget::FLAG_DISPATCH_AS_SLIPPERY_EXIT, IntSet());
 
                 // Make a slippery entrance into the new window.
                 if (newTouchedWindowHandle->getInfo()->supportsSplitTouch()) {
@@ -1304,9 +1304,9 @@
                     targetFlags |= InputTarget::FLAG_WINDOW_IS_OBSCURED;
                 }
 
-                BitSet32 pointerIds;
+                IntSet pointerIds;
                 if (isSplit) {
-                    pointerIds.markBit(entry->pointerProperties[0].id);
+                    pointerIds.insert(entry->pointerProperties[0].id);
                 }
                 mTempTouchState.addOrUpdateWindow(newTouchedWindowHandle, targetFlags, pointerIds);
             }
@@ -1321,7 +1321,7 @@
                 c_str(mLastHoverWindowHandle->getName()));
 #endif
             mTempTouchState.addOrUpdateWindow(mLastHoverWindowHandle,
-                    InputTarget::FLAG_DISPATCH_AS_HOVER_EXIT, BitSet32(0));
+                    InputTarget::FLAG_DISPATCH_AS_HOVER_EXIT, IntSet());
         }
 
         // Let the new window know that the hover sequence is starting.
@@ -1331,7 +1331,7 @@
                 c_str(newHoverWindowHandle->getName()));
 #endif
             mTempTouchState.addOrUpdateWindow(newHoverWindowHandle,
-                    InputTarget::FLAG_DISPATCH_AS_HOVER_ENTER, BitSet32(0));
+                    InputTarget::FLAG_DISPATCH_AS_HOVER_ENTER, IntSet());
         }
     }
 
@@ -1375,7 +1375,7 @@
                 sp<InputWindowHandle> inputWindowHandle = touchedWindow.windowHandle;
                 if (inputWindowHandle->getInfo()->ownerUid != foregroundWindowUid) {
                     mTempTouchState.addOrUpdateWindow(inputWindowHandle,
-                            InputTarget::FLAG_ZERO_COORDS, BitSet32(0));
+                            InputTarget::FLAG_ZERO_COORDS, IntSet());
                 }
             }
         }
@@ -1421,7 +1421,7 @@
                     mTempTouchState.addOrUpdateWindow(windowHandle,
                             InputTarget::FLAG_WINDOW_IS_OBSCURED
                                     | InputTarget::FLAG_DISPATCH_AS_IS,
-                            BitSet32(0));
+                            IntSet());
                 }
             });
         }
@@ -1491,12 +1491,12 @@
                 // One pointer went up.
                 if (isSplit) {
                     int32_t pointerIndex = getMotionEventActionPointerIndex(action);
-                    uint32_t pointerId = entry->pointerProperties[pointerIndex].id;
+                    int32_t pointerId = entry->pointerProperties[pointerIndex].id;
 
                     for (size_t i = 0; i < mTempTouchState.windows.size(); ) {
                         TouchedWindow& touchedWindow = mTempTouchState.windows.editItemAt(i);
                         if (touchedWindow.targetFlags & InputTarget::FLAG_SPLIT) {
-                            touchedWindow.pointerIds.clearBit(pointerId);
+                            touchedWindow.pointerIds.remove(pointerId);
                             if (touchedWindow.pointerIds.isEmpty()) {
                                 mTempTouchState.windows.removeAt(i);
                                 continue;
@@ -1538,7 +1538,7 @@
 }
 
 void InputDispatcher::addWindowTargetLocked(const sp<InputWindowHandle>& windowHandle,
-        int32_t targetFlags, BitSet32 pointerIds, Vector<InputTarget>& inputTargets) {
+        int32_t targetFlags, const IntSet &pointerIds, Vector<InputTarget>& inputTargets) {
     inputTargets.push();
 
     const InputWindowInfo* windowInfo = windowHandle->getInfo();
@@ -1693,12 +1693,13 @@
 void InputDispatcher::prepareDispatchCycleLocked(nsecs_t currentTime,
         const sp<Connection>& connection, EventEntry* eventEntry, const InputTarget* inputTarget) {
 #if DEBUG_DISPATCH_CYCLE
+    std::string pointerIdsString = inputTarget->pointerIds.toString();
     ALOGD("channel '%s' ~ prepareDispatchCycle - flags=0x%08x, "
             "xOffset=%f, yOffset=%f, scaleFactor=%f, "
-            "pointerIds=0x%x",
+            "pointerIds=%s",
             connection->getInputChannelName(), inputTarget->flags,
             inputTarget->xOffset, inputTarget->yOffset,
-            inputTarget->scaleFactor, inputTarget->pointerIds.value);
+            inputTarget->scaleFactor, pointerIdsString.c_str());
 #endif
 
     // Skip this event if the connection status is not normal.
@@ -2163,8 +2164,8 @@
 }
 
 InputDispatcher::MotionEntry*
-InputDispatcher::splitMotionEvent(const MotionEntry* originalMotionEntry, BitSet32 pointerIds) {
-    ALOG_ASSERT(pointerIds.value != 0);
+InputDispatcher::splitMotionEvent(const MotionEntry* originalMotionEntry, const IntSet &pointerIds) {
+    ALOG_ASSERT(!pointerIds.isEmpty());
 
     uint32_t splitPointerIndexMap[MAX_POINTERS];
     PointerProperties splitPointerProperties[MAX_POINTERS];
@@ -2178,7 +2179,7 @@
         const PointerProperties& pointerProperties =
                 originalMotionEntry->pointerProperties[originalPointerIndex];
         uint32_t pointerId = uint32_t(pointerProperties.id);
-        if (pointerIds.hasBit(pointerId)) {
+        if (pointerIds.contains(pointerId)) {
             splitPointerIndexMap[splitPointerCount] = originalPointerIndex;
             splitPointerProperties[splitPointerCount].copyFrom(pointerProperties);
             splitPointerCoords[splitPointerCount].copyFrom(
@@ -2207,8 +2208,8 @@
         int32_t originalPointerIndex = getMotionEventActionPointerIndex(action);
         const PointerProperties& pointerProperties =
                 originalMotionEntry->pointerProperties[originalPointerIndex];
-        uint32_t pointerId = uint32_t(pointerProperties.id);
-        if (pointerIds.hasBit(pointerId)) {
+        int32_t pointerId = pointerProperties.id;
+        if (pointerIds.contains(pointerId)) {
             if (pointerIds.count() == 1) {
                 // The first/last pointer went down/up.
                 action = maskedAction == AMOTION_EVENT_ACTION_POINTER_DOWN
@@ -2216,7 +2217,7 @@
             } else {
                 // A secondary pointer went down/up.
                 uint32_t splitPointerIndex = 0;
-                while (pointerId != uint32_t(splitPointerProperties[splitPointerIndex].id)) {
+                while (pointerId != splitPointerProperties[splitPointerIndex].id) {
                     splitPointerIndex += 1;
                 }
                 action = maskedAction | (splitPointerIndex
@@ -2901,7 +2902,7 @@
             const TouchedWindow& touchedWindow = mTouchState.windows[i];
             if (touchedWindow.windowHandle == fromWindowHandle) {
                 int32_t oldTargetFlags = touchedWindow.targetFlags;
-                BitSet32 pointerIds = touchedWindow.pointerIds;
+                IntSet pointerIds = touchedWindow.pointerIds;
 
                 mTouchState.windows.removeAt(i);
 
@@ -3000,10 +3001,14 @@
         dump.append(INDENT "TouchedWindows:\n");
         for (size_t i = 0; i < mTouchState.windows.size(); i++) {
             const TouchedWindow& touchedWindow = mTouchState.windows[i];
-            appendFormat(dump, INDENT2 "%d: name='%s', pointerIds=0x%0x, targetFlags=0x%x\n",
-                    i, c_str(touchedWindow.windowHandle->getName()),
-                    touchedWindow.pointerIds.value,
-                    touchedWindow.targetFlags);
+            appendFormat(dump, INDENT2 "%d: name='%s'",
+                    i, c_str(touchedWindow.windowHandle->getName()));
+
+            dump.append(", pointerIds=(");
+            touchedWindow.pointerIds.forEach([&](int32_t id) {appendFormat(dump, ", %d", id);});
+            dump.append(")");
+
+            appendFormat(dump, ", targetFlags=0x%x\n", touchedWindow.targetFlags);
         }
     } else {
         dump.append(INDENT "TouchedWindows: <none>\n");
@@ -4191,7 +4196,7 @@
 }
 
 void InputDispatcher::TouchState::addOrUpdateWindow(const sp<InputWindowHandle>& windowHandle,
-        int32_t targetFlags, BitSet32 pointerIds) {
+        int32_t targetFlags, const IntSet &pointerIds) {
     if (targetFlags & InputTarget::FLAG_SPLIT) {
         split = true;
     }
@@ -4203,7 +4208,9 @@
             if (targetFlags & InputTarget::FLAG_DISPATCH_AS_SLIPPERY_EXIT) {
                 touchedWindow.targetFlags &= ~InputTarget::FLAG_DISPATCH_AS_IS;
             }
-            touchedWindow.pointerIds.value |= pointerIds.value;
+            pointerIds.forEach([&](int32_t id) {
+                touchedWindow.pointerIds.insert(id);
+            });
             return;
         }
     }

=== modified file '3rd_party/android-input/android/frameworks/base/services/input/InputDispatcher.h'
--- 3rd_party/android-input/android/frameworks/base/services/input/InputDispatcher.h	2013-05-30 19:24:29 +0000
+++ 3rd_party/android-input/android/frameworks/base/services/input/InputDispatcher.h	2013-11-25 03:07:43 +0000
@@ -19,13 +19,13 @@
 
 #include <androidfw/Input.h>
 #include <androidfw/InputTransport.h>
+#include <androidfw/IntSet.h>
 #include <std/KeyedVector.h>
 #include <std/Vector.h>
 #include <std/Timers.h>
 #include <std/RefBase.h>
 #include <std/String8.h>
 #include <std/Looper.h>
-#include <std/BitSet.h>
 #include <std/atomic.h>
 #include <std/Condition.h>
 #include <std/Thread.h>
@@ -169,7 +169,7 @@
 
     // The subset of pointer ids to include in motion events dispatched to this input target
     // if FLAG_SPLIT is set.
-    BitSet32 pointerIds;
+    IntSet pointerIds;
 };
 
 
@@ -953,7 +953,7 @@
     struct TouchedWindow {
         sp<InputWindowHandle> windowHandle;
         int32_t targetFlags;
-        BitSet32 pointerIds;        // zero unless target flag FLAG_SPLIT is set
+        IntSet pointerIds;        // empty unless target flag FLAG_SPLIT is set
     };
     struct TouchState {
         bool down;
@@ -967,7 +967,7 @@
         void reset();
         void copyFrom(const TouchState& other);
         void addOrUpdateWindow(const sp<InputWindowHandle>& windowHandle,
-                int32_t targetFlags, BitSet32 pointerIds);
+                int32_t targetFlags, const IntSet &pointerIds);
         void removeWindow(const sp<InputWindowHandle>& windowHandle);
         void filterNonAsIsTouchWindows();
         sp<InputWindowHandle> getFirstForegroundWindowHandle() const;
@@ -1033,7 +1033,7 @@
             bool* outConflictingPointerActions);
 
     void addWindowTargetLocked(const sp<InputWindowHandle>& windowHandle,
-            int32_t targetFlags, BitSet32 pointerIds, Vector<InputTarget>& inputTargets);
+            int32_t targetFlags, const IntSet &pointerIds, Vector<InputTarget>& inputTargets);
     void addMonitoringTargetsLocked(Vector<InputTarget>& inputTargets);
 
     bool checkInjectionPermission(const sp<InputWindowHandle>& windowHandle,
@@ -1072,7 +1072,7 @@
             const CancelationOptions& options);
 
     // Splitting motion events across windows.
-    MotionEntry* splitMotionEvent(const MotionEntry* originalMotionEntry, BitSet32 pointerIds);
+    MotionEntry* splitMotionEvent(const MotionEntry* originalMotionEntry, const IntSet &pointerIds);
 
     // Reset and drop everything the dispatcher is doing.
     void resetAndDropEverythingLocked(const char* reason);

=== added file '3rd_party/android-input/android/frameworks/base/services/input/InputEventPrinter.h'
--- 3rd_party/android-input/android/frameworks/base/services/input/InputEventPrinter.h	1970-01-01 00:00:00 +0000
+++ 3rd_party/android-input/android/frameworks/base/services/input/InputEventPrinter.h	2013-11-25 03:07:43 +0000
@@ -0,0 +1,138 @@
+/*
+ * Copyright © 2013 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License version 3,
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Author: Daniel d'Andrada <[e-mail]>
+ */
+
+#ifndef INPUT_EVENT_PRINTER_H
+#define INPUT_EVENT_PRINTER_H
+
+#include <stdio.h>
+
+void synEvCodeToStr(char *codeStr, int code) {
+    switch(code) {
+        case SYN_REPORT:
+            sprintf(codeStr, "SYN_REPORT");
+            break;
+        case SYN_CONFIG:
+            sprintf(codeStr, "SYN_CONFIG");
+            break;
+        case SYN_MT_REPORT:
+            sprintf(codeStr, "SYN_MT_REPORT");
+            break;
+        case SYN_DROPPED:
+            sprintf(codeStr, "SYN_DROPPED");
+            break;
+        default:
+            sprintf(codeStr, "0x%08x", code);
+            break;
+    }
+}
+
+void absEvCodeToStr(char *codeStr, int code) {
+    switch(code) {
+        case ABS_X:
+            sprintf(codeStr, "ABS_X");
+            break;
+        case ABS_Y:
+            sprintf(codeStr, "ABS_Y");
+            break;
+        case ABS_MT_TOUCH_MAJOR:
+            sprintf(codeStr, "ABS_MT_TOUCH_MAJOR");
+            break;
+        case ABS_MT_TOUCH_MINOR:
+            sprintf(codeStr, "ABS_MT_TOUCH_MINOR");
+            break;
+        case ABS_MT_ORIENTATION:
+            sprintf(codeStr, "ABS_MT_ORIENTATION");
+            break;
+        case ABS_MT_POSITION_X:
+            sprintf(codeStr, "ABS_MT_POSITION_X");
+            break;
+        case ABS_MT_POSITION_Y:
+            sprintf(codeStr, "ABS_MT_POSITION_Y");
+            break;
+        case ABS_MT_TOOL_TYPE:
+            sprintf(codeStr, "ABS_MT_TOOL_TYPE");
+            break;
+        default:
+            sprintf(codeStr, "0x%08x", code);
+            break;
+    }
+}
+
+void keyEvCodeToStr(char *codeStr, int code) {
+    switch(code) {
+        case BTN_TOUCH:
+            sprintf(codeStr, "BTN_TOUCH");
+            break;
+        case BTN_STYLUS:
+            sprintf(codeStr, "BTN_STYLUS");
+            break;
+        default:
+            sprintf(codeStr, "0x%08x", code);
+            break;
+    }
+}
+
+void inputEvToStr(char *buffer, int type, int code, int value) {
+    char codeStr[100];
+    switch (type) {
+    case EV_SYN:
+        synEvCodeToStr(codeStr, code);
+        sprintf(buffer, "EV_SYN, %s, 0x%08x", codeStr, value);
+        break;
+    case EV_KEY:
+        keyEvCodeToStr(codeStr, code);
+        sprintf(buffer, "EV_KEY, %s, 0x%08x", codeStr, value);
+        break;
+    case EV_REL:
+        sprintf(buffer, "EV_REL, 0x%08x, 0x%08x", code, value);
+        break;
+    case EV_ABS:
+        absEvCodeToStr(codeStr, code);
+        sprintf(buffer, "EV_ABS, %s, 0x%08x", codeStr, value);
+        break;
+    case EV_MSC:
+        sprintf(buffer, "EV_MSC, 0x%08x, 0x%08x", code, value);
+        break;
+    case EV_SW:
+        sprintf(buffer, "EV_SW, 0x%08x, 0x%08x", code, value);
+        break;
+    case EV_LED:
+        sprintf(buffer, "EV_LED, 0x%08x, 0x%08x", code, value);
+        break;
+    case EV_SND:
+        sprintf(buffer, "EV_SND, 0x%08x, 0x%08x", code, value);
+        break;
+    case EV_REP:
+        sprintf(buffer, "EV_REP, 0x%08x, 0x%08x", code, value);
+        break;
+    case EV_FF:
+        sprintf(buffer, "EV_FF, 0x%08x, 0x%08x", code, value);
+        break;
+    case EV_PWR:
+        sprintf(buffer, "EV_PWR, 0x%08x, 0x%08x", code, value);
+        break;
+    case EV_FF_STATUS:
+        sprintf(buffer, "EV_FF_STATUS, 0x%08x, 0x%08x", code, value);
+        break;
+    default:
+        sprintf(buffer, "0x%08x, 0x%08x, 0x%08x", type, code, value);
+        break;
+    }
+}
+
+#endif // INPUT_EVENT_PRINTER_H

=== modified file '3rd_party/android-input/android/frameworks/base/services/input/InputListener.h'
--- 3rd_party/android-input/android/frameworks/base/services/input/InputListener.h	2013-05-03 16:38:07 +0000
+++ 3rd_party/android-input/android/frameworks/base/services/input/InputListener.h	2013-11-25 03:07:43 +0000
@@ -38,7 +38,7 @@
 struct NotifyConfigurationChangedArgs : public NotifyArgs {
     nsecs_t eventTime;
 
-    inline NotifyConfigurationChangedArgs() { }
+    inline NotifyConfigurationChangedArgs() : eventTime{0} { }
 
     NotifyConfigurationChangedArgs(nsecs_t eventTime);
 

=== modified file '3rd_party/android-input/android/frameworks/base/services/input/InputReader.cpp'
--- 3rd_party/android-input/android/frameworks/base/services/input/InputReader.cpp	2013-10-15 08:53:10 +0000
+++ 3rd_party/android-input/android/frameworks/base/services/input/InputReader.cpp	2013-11-25 03:07:43 +0000
@@ -47,6 +47,8 @@
 
 #include <android/keycodes.h>
 
+#include <std/BitSet.h>
+
 #include <stddef.h>
 #include <stdlib.h>
 #include <unistd.h>
@@ -54,6 +56,10 @@
 #include <limits.h>
 #include <math.h>
 
+#if DEBUG_RAW_EVENTS
+#include "InputEventPrinter.h"
+#endif
+
 #define INDENT "  "
 #define INDENT2 "    "
 #define INDENT3 "      "
@@ -339,7 +345,7 @@
                 batchSize += 1;
             }
 #if DEBUG_RAW_EVENTS
-            ALOGD("BatchSize: %d Count: %d", batchSize, count);
+            ALOGD("BatchSize: %zu Count: %zu", batchSize, count);
 #endif
             processEventsForDeviceLocked(deviceId, rawEvent, batchSize);
         } else {
@@ -974,8 +980,9 @@
     size_t numMappers = mMappers.size();
     for (const RawEvent* rawEvent = rawEvents; count--; rawEvent++) {
 #if DEBUG_RAW_EVENTS
-        ALOGD("Input event: device=%d type=0x%04x code=0x%04x value=0x%08x",
-                rawEvent->deviceId, rawEvent->type, rawEvent->code, rawEvent->value);
+        char inputStr[200];
+        inputEvToStr(inputStr, rawEvent->type, rawEvent->code, rawEvent->value);
+        ALOGD("Input event: device=%d %s", rawEvent->deviceId, inputStr);
 #endif
 
         if (mDropUntilNextSync) {
@@ -1434,32 +1441,31 @@
 
 void RawPointerData::clear() {
     pointerCount = 0;
-    clearIdBits();
+    clearIds();
 }
 
 void RawPointerData::copyFrom(const RawPointerData& other) {
     pointerCount = other.pointerCount;
-    hoveringIdBits = other.hoveringIdBits;
-    touchingIdBits = other.touchingIdBits;
+    hoveringIds = other.hoveringIds;
+    touchingIds = other.touchingIds;
 
     for (uint32_t i = 0; i < pointerCount; i++) {
         pointers[i] = other.pointers[i];
 
         int id = pointers[i].id;
-        idToIndex[id] = other.idToIndex[id];
     }
 }
 
 void RawPointerData::getCentroidOfTouchingPointers(float* outX, float* outY) const {
     float x = 0, y = 0;
-    uint32_t count = touchingIdBits.count();
+
+    uint32_t count = touchingIds.count();
     if (count) {
-        for (BitSet32 idBits(touchingIdBits); !idBits.isEmpty(); ) {
-            uint32_t id = idBits.clearFirstMarkedBit();
+        touchingIds.forEach([&](int32_t id) {
             const Pointer& pointer = pointerForId(id);
             x += pointer.x;
             y += pointer.y;
-        }
+        });
         x /= count;
         y /= count;
     }
@@ -1476,21 +1482,18 @@
 
 void CookedPointerData::clear() {
     pointerCount = 0;
-    hoveringIdBits.clear();
-    touchingIdBits.clear();
+    hoveringIds.clear();
+    touchingIds.clear();
 }
 
 void CookedPointerData::copyFrom(const CookedPointerData& other) {
     pointerCount = other.pointerCount;
-    hoveringIdBits = other.hoveringIdBits;
-    touchingIdBits = other.touchingIdBits;
+    hoveringIds = other.hoveringIds;
+    touchingIds = other.touchingIds;
 
     for (uint32_t i = 0; i < pointerCount; i++) {
         pointerProperties[i].copyFrom(other.pointerProperties[i]);
         pointerCoords[i].copyFrom(other.pointerCoords[i]);
-
-        int id = pointerProperties[i].id;
-        idToIndex[id] = other.idToIndex[id];
     }
 }
 
@@ -2554,7 +2557,8 @@
         InputMapper(device),
         mSource(0), mDeviceMode(DEVICE_MODE_DISABLED),
         mSurfaceOrientation(-1), mSurfaceWidth(-1), mSurfaceHeight(-1),
-        mPointerUsage(POINTER_USAGE_NONE) {
+        mPointerUsage(POINTER_USAGE_NONE),
+        mNextNewPointerId(0) {
 }
 
 TouchInputMapper::~TouchInputMapper() {
@@ -3499,12 +3503,12 @@
     mLastButtonState = 0;
     mCurrentRawVScroll = 0;
     mCurrentRawHScroll = 0;
-    mCurrentFingerIdBits.clear();
-    mLastFingerIdBits.clear();
-    mCurrentStylusIdBits.clear();
-    mLastStylusIdBits.clear();
-    mCurrentMouseIdBits.clear();
-    mLastMouseIdBits.clear();
+    mCurrentFingerIds.clear();
+    mLastFingerIds.clear();
+    mCurrentStylusIds.clear();
+    mLastStylusIds.clear();
+    mCurrentMouseIds.clear();
+    mLastMouseIds.clear();
     mPointerUsage = POINTER_USAGE_NONE;
     mSentHoverEnter = false;
     mDownTime = 0;
@@ -3553,21 +3557,25 @@
                 mLastRawPointerData.pointerCount,
                 mCurrentRawPointerData.pointerCount);
     } else {
-        ALOGD("syncTouch: pointerCount %d -> %d, touching ids 0x%08x -> 0x%08x, "
-                "hovering ids 0x%08x -> 0x%08x",
+        std::string lastTouchingIdsString = mLastRawPointerData.touchingIds.toString();
+        std::string currentTouchingIdsString = mCurrentRawPointerData.touchingIds.toString();
+        std::string lastHoveringIdsString = mLastRawPointerData.hoveringIds.toString();
+        std::string currentHoveringIdsString = mCurrentRawPointerData.hoveringIds.toString();
+        ALOGD("syncTouch: pointerCount %u -> %u, touching ids (%s) -> (%s), "
+                "hovering ids (%s) -> (%s)",
                 mLastRawPointerData.pointerCount,
                 mCurrentRawPointerData.pointerCount,
-                mLastRawPointerData.touchingIdBits.value,
-                mCurrentRawPointerData.touchingIdBits.value,
-                mLastRawPointerData.hoveringIdBits.value,
-                mCurrentRawPointerData.hoveringIdBits.value);
+                lastTouchingIdsString.c_str(),
+                currentTouchingIdsString.c_str(),
+                lastHoveringIdsString.c_str(),
+                currentHoveringIdsString.c_str());
     }
 #endif
 
     // Reset state that we will compute below.
-    mCurrentFingerIdBits.clear();
-    mCurrentStylusIdBits.clear();
-    mCurrentMouseIdBits.clear();
+    mCurrentFingerIds.clear();
+    mCurrentStylusIds.clear();
+    mCurrentMouseIds.clear();
     mCurrentCookedPointerData.clear();
 
     if (mDeviceMode == DEVICE_MODE_DISABLED) {
@@ -3617,38 +3625,36 @@
 
         // Dispatch the touches either directly or by translation through a pointer on screen.
         if (mDeviceMode == DEVICE_MODE_POINTER) {
-            for (BitSet32 idBits(mCurrentRawPointerData.touchingIdBits); !idBits.isEmpty(); ) {
-                uint32_t id = idBits.clearFirstMarkedBit();
-                const RawPointerData::Pointer& pointer = mCurrentRawPointerData.pointerForId(id);
+            for (uint32_t i = 0; i < mCurrentRawPointerData.pointerCount; ++i) {
+                const RawPointerData::Pointer& pointer = mCurrentRawPointerData.pointers[i];
                 if (pointer.toolType == AMOTION_EVENT_TOOL_TYPE_STYLUS
                         || pointer.toolType == AMOTION_EVENT_TOOL_TYPE_ERASER) {
-                    mCurrentStylusIdBits.markBit(id);
+                    mCurrentStylusIds.insert(pointer.id);
                 } else if (pointer.toolType == AMOTION_EVENT_TOOL_TYPE_FINGER
                         || pointer.toolType == AMOTION_EVENT_TOOL_TYPE_UNKNOWN) {
-                    mCurrentFingerIdBits.markBit(id);
+                    mCurrentFingerIds.insert(pointer.id);
                 } else if (pointer.toolType == AMOTION_EVENT_TOOL_TYPE_MOUSE) {
-                    mCurrentMouseIdBits.markBit(id);
+                    mCurrentMouseIds.insert(pointer.id);
                 }
             }
-            for (BitSet32 idBits(mCurrentRawPointerData.hoveringIdBits); !idBits.isEmpty(); ) {
-                uint32_t id = idBits.clearFirstMarkedBit();
+            mCurrentRawPointerData.hoveringIds.forEach([&](int32_t id) {
                 const RawPointerData::Pointer& pointer = mCurrentRawPointerData.pointerForId(id);
                 if (pointer.toolType == AMOTION_EVENT_TOOL_TYPE_STYLUS
                         || pointer.toolType == AMOTION_EVENT_TOOL_TYPE_ERASER) {
-                    mCurrentStylusIdBits.markBit(id);
+                    mCurrentStylusIds.insert(id);
                 }
-            }
+            });
 
             // Stylus takes precedence over all tools, then mouse, then finger.
             PointerUsage pointerUsage = mPointerUsage;
-            if (!mCurrentStylusIdBits.isEmpty()) {
-                mCurrentMouseIdBits.clear();
-                mCurrentFingerIdBits.clear();
+            if (!mCurrentStylusIds.isEmpty()) {
+                mCurrentMouseIds.clear();
+                mCurrentFingerIds.clear();
                 pointerUsage = POINTER_USAGE_STYLUS;
-            } else if (!mCurrentMouseIdBits.isEmpty()) {
-                mCurrentFingerIdBits.clear();
+            } else if (!mCurrentMouseIds.isEmpty()) {
+                mCurrentFingerIds.clear();
                 pointerUsage = POINTER_USAGE_MOUSE;
-            } else if (!mCurrentFingerIdBits.isEmpty() || isPointerDown(mCurrentButtonState)) {
+            } else if (!mCurrentFingerIds.isEmpty() || isPointerDown(mCurrentButtonState)) {
                 pointerUsage = POINTER_USAGE_GESTURES;
             }
 
@@ -3661,8 +3667,7 @@
 
                 mPointerController->setButtonState(mCurrentButtonState);
                 mPointerController->setSpots(mCurrentCookedPointerData.pointerCoords,
-                        mCurrentCookedPointerData.idToIndex,
-                        mCurrentCookedPointerData.touchingIdBits);
+                        mCurrentCookedPointerData.pointerCount);
             }
 
             dispatchHoverExit(when, policyFlags);
@@ -3679,9 +3684,9 @@
     mLastRawPointerData.copyFrom(mCurrentRawPointerData);
     mLastCookedPointerData.copyFrom(mCurrentCookedPointerData);
     mLastButtonState = mCurrentButtonState;
-    mLastFingerIdBits = mCurrentFingerIdBits;
-    mLastStylusIdBits = mCurrentStylusIdBits;
-    mLastMouseIdBits = mCurrentMouseIdBits;
+    mLastFingerIds = mCurrentFingerIds;
+    mLastStylusIds = mCurrentStylusIds;
+    mLastMouseIds = mCurrentMouseIds;
 
     // Clear some transient state.
     mCurrentRawVScroll = 0;
@@ -3699,7 +3704,7 @@
 bool TouchInputMapper::consumeRawTouches(nsecs_t when, uint32_t policyFlags) {
     // Check for release of a virtual key.
     if (mCurrentVirtualKey.down) {
-        if (mCurrentRawPointerData.touchingIdBits.isEmpty()) {
+        if (mCurrentRawPointerData.touchingIds.isEmpty()) {
             // Pointer went up while virtual key was down.
             mCurrentVirtualKey.down = false;
             if (!mCurrentVirtualKey.ignored) {
@@ -3714,8 +3719,8 @@
             return true;
         }
 
-        if (mCurrentRawPointerData.touchingIdBits.count() == 1) {
-            uint32_t id = mCurrentRawPointerData.touchingIdBits.firstMarkedBit();
+        if (mCurrentRawPointerData.touchingIds.count() == 1) {
+            int32_t id = mCurrentRawPointerData.touchingIds.first();
             const RawPointerData::Pointer& pointer = mCurrentRawPointerData.pointerForId(id);
             const VirtualKey* virtualKey = findVirtualKeyHit(pointer.x, pointer.y);
             if (virtualKey && virtualKey->keyCode == mCurrentVirtualKey.keyCode) {
@@ -3741,15 +3746,15 @@
         }
     }
 
-    if (mLastRawPointerData.touchingIdBits.isEmpty()
-            && !mCurrentRawPointerData.touchingIdBits.isEmpty()) {
+    if (mLastRawPointerData.touchingIds.isEmpty()
+            && !mCurrentRawPointerData.touchingIds.isEmpty()) {
         // Pointer just went down.  Check for virtual key press or off-screen touches.
-        uint32_t id = mCurrentRawPointerData.touchingIdBits.firstMarkedBit();
+        int32_t id = mCurrentRawPointerData.touchingIds.first();
         const RawPointerData::Pointer& pointer = mCurrentRawPointerData.pointerForId(id);
         if (!isPointInsideSurface(pointer.x, pointer.y)) {
             // If exactly one pointer went down, check for virtual key hit.
             // Otherwise we will drop the entire stroke.
-            if (mCurrentRawPointerData.touchingIdBits.count() == 1) {
+            if (mCurrentRawPointerData.touchingIds.count() == 1) {
                 const VirtualKey* virtualKey = findVirtualKeyHit(pointer.x, pointer.y);
                 if (virtualKey) {
                     mCurrentVirtualKey.down = true;
@@ -3789,7 +3794,7 @@
     //    area and accidentally triggers a virtual key.  This often happens when virtual keys
     //    are layed out below the screen near to where the on screen keyboard's space bar
     //    is displayed.
-    if (mConfig.virtualKeyQuietTime > 0 && !mCurrentRawPointerData.touchingIdBits.isEmpty()) {
+    if (mConfig.virtualKeyQuietTime > 0 && !mCurrentRawPointerData.touchingIds.isEmpty()) {
         mContext->disableVirtualKeysUntil(when + mConfig.virtualKeyQuietTime);
     }
     return false;
@@ -3809,13 +3814,13 @@
 }
 
 void TouchInputMapper::dispatchTouches(nsecs_t when, uint32_t policyFlags) {
-    BitSet32 currentIdBits = mCurrentCookedPointerData.touchingIdBits;
-    BitSet32 lastIdBits = mLastCookedPointerData.touchingIdBits;
+    IntSet &currentIds = mCurrentCookedPointerData.touchingIds;
+    IntSet &lastIds = mLastCookedPointerData.touchingIds;
     int32_t metaState = getContext()->getGlobalMetaState();
     int32_t buttonState = mCurrentButtonState;
 
-    if (currentIdBits == lastIdBits) {
-        if (!currentIdBits.isEmpty()) {
+    if (currentIds == lastIds) {
+        if (!currentIds.isEmpty()) {
             // No pointer id changes so this is a move event.
             // The listener takes care of batching moves so we don't have to deal with that here.
             dispatchMotion(when, policyFlags, mSource,
@@ -3823,66 +3828,63 @@
                     AMOTION_EVENT_EDGE_FLAG_NONE,
                     mCurrentCookedPointerData.pointerProperties,
                     mCurrentCookedPointerData.pointerCoords,
-                    mCurrentCookedPointerData.idToIndex,
-                    currentIdBits, -1,
+                    mCurrentCookedPointerData.pointerCount,
+                    currentIds, -1,
                     mOrientedXPrecision, mOrientedYPrecision, mDownTime);
         }
     } else {
         // There may be pointers going up and pointers going down and pointers moving
         // all at the same time.
-        BitSet32 upIdBits(lastIdBits.value & ~currentIdBits.value);
-        BitSet32 downIdBits(currentIdBits.value & ~lastIdBits.value);
-        BitSet32 moveIdBits(lastIdBits.value & currentIdBits.value);
-        BitSet32 dispatchedIdBits(lastIdBits.value);
+        IntSet upIds = lastIds - currentIds;
+        IntSet downIds = currentIds - lastIds;
+        IntSet moveIds = lastIds & currentIds;
+        IntSet dispatchedIds = lastIds;
 
         // Update last coordinates of pointers that have moved so that we observe the new
         // pointer positions at the same time as other pointers that have just gone up.
         bool moveNeeded = updateMovedPointers(
                 mCurrentCookedPointerData.pointerProperties,
                 mCurrentCookedPointerData.pointerCoords,
-                mCurrentCookedPointerData.idToIndex,
+                mCurrentCookedPointerData.pointerCount,
                 mLastCookedPointerData.pointerProperties,
                 mLastCookedPointerData.pointerCoords,
-                mLastCookedPointerData.idToIndex,
-                moveIdBits);
+                mLastCookedPointerData.pointerCount,
+                moveIds);
         if (buttonState != mLastButtonState) {
             moveNeeded = true;
         }
 
         // Dispatch pointer up events.
-        while (!upIdBits.isEmpty()) {
-            uint32_t upId = upIdBits.clearFirstMarkedBit();
-
+        upIds.forEach([&](int32_t upId) {
             dispatchMotion(when, policyFlags, mSource,
                     AMOTION_EVENT_ACTION_POINTER_UP, 0, metaState, buttonState, 0,
                     mLastCookedPointerData.pointerProperties,
                     mLastCookedPointerData.pointerCoords,
-                    mLastCookedPointerData.idToIndex,
-                    dispatchedIdBits, upId,
+                    mLastCookedPointerData.pointerCount,
+                    dispatchedIds, upId,
                     mOrientedXPrecision, mOrientedYPrecision, mDownTime);
-            dispatchedIdBits.clearBit(upId);
-        }
+            dispatchedIds.remove(upId);
+        });
 
         // Dispatch move events if any of the remaining pointers moved from their old locations.
         // Although applications receive new locations as part of individual pointer up
         // events, they do not generally handle them except when presented in a move event.
         if (moveNeeded) {
-            ALOG_ASSERT(moveIdBits.value == dispatchedIdBits.value);
+            ALOG_ASSERT(moveIds == dispatchedIds);
             dispatchMotion(when, policyFlags, mSource,
                     AMOTION_EVENT_ACTION_MOVE, 0, metaState, buttonState, 0,
                     mCurrentCookedPointerData.pointerProperties,
                     mCurrentCookedPointerData.pointerCoords,
-                    mCurrentCookedPointerData.idToIndex,
-                    dispatchedIdBits, -1,
+                    mCurrentCookedPointerData.pointerCount,
+                    dispatchedIds, -1,
                     mOrientedXPrecision, mOrientedYPrecision, mDownTime);
         }
 
         // Dispatch pointer down events using the new pointer locations.
-        while (!downIdBits.isEmpty()) {
-            uint32_t downId = downIdBits.clearFirstMarkedBit();
-            dispatchedIdBits.markBit(downId);
+        downIds.forEach([&](int32_t downId) {
+            dispatchedIds.insert(downId);
 
-            if (dispatchedIdBits.count() == 1) {
+            if (dispatchedIds.count() == 1) {
                 // First pointer is going down.  Set down time.
                 mDownTime = when;
             }
@@ -3891,40 +3893,40 @@
                     AMOTION_EVENT_ACTION_POINTER_DOWN, 0, metaState, buttonState, 0,
                     mCurrentCookedPointerData.pointerProperties,
                     mCurrentCookedPointerData.pointerCoords,
-                    mCurrentCookedPointerData.idToIndex,
-                    dispatchedIdBits, downId,
+                    mCurrentCookedPointerData.pointerCount,
+                    dispatchedIds, downId,
                     mOrientedXPrecision, mOrientedYPrecision, mDownTime);
-        }
+        });
     }
 }
 
 void TouchInputMapper::dispatchHoverExit(nsecs_t when, uint32_t policyFlags) {
     if (mSentHoverEnter &&
-            (mCurrentCookedPointerData.hoveringIdBits.isEmpty()
-                    || !mCurrentCookedPointerData.touchingIdBits.isEmpty())) {
+            (mCurrentCookedPointerData.hoveringIds.isEmpty()
+                    || !mCurrentCookedPointerData.touchingIds.isEmpty())) {
         int32_t metaState = getContext()->getGlobalMetaState();
         dispatchMotion(when, policyFlags, mSource,
                 AMOTION_EVENT_ACTION_HOVER_EXIT, 0, metaState, mLastButtonState, 0,
                 mLastCookedPointerData.pointerProperties,
                 mLastCookedPointerData.pointerCoords,
-                mLastCookedPointerData.idToIndex,
-                mLastCookedPointerData.hoveringIdBits, -1,
+                mLastCookedPointerData.pointerCount,
+                mLastCookedPointerData.hoveringIds, -1,
                 mOrientedXPrecision, mOrientedYPrecision, mDownTime);
         mSentHoverEnter = false;
     }
 }
 
 void TouchInputMapper::dispatchHoverEnterAndMove(nsecs_t when, uint32_t policyFlags) {
-    if (mCurrentCookedPointerData.touchingIdBits.isEmpty()
-            && !mCurrentCookedPointerData.hoveringIdBits.isEmpty()) {
+    if (mCurrentCookedPointerData.touchingIds.isEmpty()
+            && !mCurrentCookedPointerData.hoveringIds.isEmpty()) {
         int32_t metaState = getContext()->getGlobalMetaState();
         if (!mSentHoverEnter) {
             dispatchMotion(when, policyFlags, mSource,
                     AMOTION_EVENT_ACTION_HOVER_ENTER, 0, metaState, mCurrentButtonState, 0,
                     mCurrentCookedPointerData.pointerProperties,
                     mCurrentCookedPointerData.pointerCoords,
-                    mCurrentCookedPointerData.idToIndex,
-                    mCurrentCookedPointerData.hoveringIdBits, -1,
+                    mCurrentCookedPointerData.pointerCount,
+                    mCurrentCookedPointerData.hoveringIds, -1,
                     mOrientedXPrecision, mOrientedYPrecision, mDownTime);
             mSentHoverEnter = true;
         }
@@ -3933,8 +3935,8 @@
                 AMOTION_EVENT_ACTION_HOVER_MOVE, 0, metaState, mCurrentButtonState, 0,
                 mCurrentCookedPointerData.pointerProperties,
                 mCurrentCookedPointerData.pointerCoords,
-                mCurrentCookedPointerData.idToIndex,
-                mCurrentCookedPointerData.hoveringIdBits, -1,
+                mCurrentCookedPointerData.pointerCount,
+                mCurrentCookedPointerData.hoveringIds, -1,
                 mOrientedXPrecision, mOrientedYPrecision, mDownTime);
     }
 }
@@ -3944,8 +3946,8 @@
 
     mCurrentCookedPointerData.clear();
     mCurrentCookedPointerData.pointerCount = currentPointerCount;
-    mCurrentCookedPointerData.hoveringIdBits = mCurrentRawPointerData.hoveringIdBits;
-    mCurrentCookedPointerData.touchingIdBits = mCurrentRawPointerData.touchingIdBits;
+    mCurrentCookedPointerData.hoveringIds = mCurrentRawPointerData.hoveringIds;
+    mCurrentCookedPointerData.touchingIds = mCurrentRawPointerData.touchingIds;
 
     // Walk through the the active pointers and map device coordinates onto
     // surface coordinates and adjust for display orientation.
@@ -3988,7 +3990,7 @@
             }
 
             if (mCalibration.haveSizeIsSummed && mCalibration.sizeIsSummed) {
-                uint32_t touchingCount = mCurrentRawPointerData.touchingIdBits.count();
+                uint32_t touchingCount = mCurrentRawPointerData.touchingIds.count();
                 if (touchingCount > 1) {
                     touchMajor /= touchingCount;
                     touchMinor /= touchingCount;
@@ -4137,9 +4139,6 @@
         properties.clear();
         properties.id = id;
         properties.toolType = in.toolType;
-
-        // Write id index.
-        mCurrentCookedPointerData.idToIndex[id] = i;
     }
 }
 
@@ -4203,8 +4202,7 @@
             mPointerController->clearSpots();
         }
         mPointerController->setSpots(mPointerGesture.currentGestureCoords,
-                mPointerGesture.currentGestureIdToIndex,
-                mPointerGesture.currentGestureIdBits);
+                mPointerGesture.currentGestureIds.count());
     } else {
         mPointerController->setPresentation(PointerControllerInterface::PRESENTATION_POINTER);
     }
@@ -4255,54 +4253,52 @@
             || mPointerGesture.currentGestureMode == PointerGesture::FREEFORM;
     bool moveNeeded = false;
     if (down && !cancelPreviousGesture && !finishPreviousGesture
-            && !mPointerGesture.lastGestureIdBits.isEmpty()
-            && !mPointerGesture.currentGestureIdBits.isEmpty()) {
-        BitSet32 movedGestureIdBits(mPointerGesture.currentGestureIdBits.value
-                & mPointerGesture.lastGestureIdBits.value);
+            && !(mPointerGesture.lastGestureIds.isEmpty())
+            && !(mPointerGesture.currentGestureIds.isEmpty())) {
+        IntSet movedGestureIds = mPointerGesture.currentGestureIds & mPointerGesture.lastGestureIds;
         moveNeeded = updateMovedPointers(mPointerGesture.currentGestureProperties,
-                mPointerGesture.currentGestureCoords, mPointerGesture.currentGestureIdToIndex,
+                mPointerGesture.currentGestureCoords, mPointerGesture.currentGestureIds.count(),
                 mPointerGesture.lastGestureProperties,
-                mPointerGesture.lastGestureCoords, mPointerGesture.lastGestureIdToIndex,
-                movedGestureIdBits);
+                mPointerGesture.lastGestureCoords, mPointerGesture.lastGestureIds.count(),
+                movedGestureIds);
         if (buttonState != mLastButtonState) {
             moveNeeded = true;
         }
     }
 
     // Send motion events for all pointers that went up or were canceled.
-    BitSet32 dispatchedGestureIdBits(mPointerGesture.lastGestureIdBits);
-    if (!dispatchedGestureIdBits.isEmpty()) {
+    IntSet dispatchedGestureIds = mPointerGesture.lastGestureIds;
+    if (!dispatchedGestureIds.isEmpty()) {
         if (cancelPreviousGesture) {
             dispatchMotion(when, policyFlags, mSource,
                     AMOTION_EVENT_ACTION_CANCEL, 0, metaState, buttonState,
                     AMOTION_EVENT_EDGE_FLAG_NONE,
                     mPointerGesture.lastGestureProperties,
-                    mPointerGesture.lastGestureCoords, mPointerGesture.lastGestureIdToIndex,
-                    dispatchedGestureIdBits, -1,
+                    mPointerGesture.lastGestureCoords, mPointerGesture.lastGestureIds.count(),
+                    dispatchedGestureIds, -1,
                     0, 0, mPointerGesture.downTime);
 
-            dispatchedGestureIdBits.clear();
+            dispatchedGestureIds.clear();
         } else {
-            BitSet32 upGestureIdBits;
+            IntSet upGestureIds;
             if (finishPreviousGesture) {
-                upGestureIdBits = dispatchedGestureIdBits;
+                upGestureIds = dispatchedGestureIds;
             } else {
-                upGestureIdBits.value = dispatchedGestureIdBits.value
-                        & ~mPointerGesture.currentGestureIdBits.value;
+                upGestureIds = dispatchedGestureIds - mPointerGesture.currentGestureIds;
             }
-            while (!upGestureIdBits.isEmpty()) {
-                uint32_t id = upGestureIdBits.clearFirstMarkedBit();
+
+            upGestureIds.forEach([&](int32_t upId) {
 
                 dispatchMotion(when, policyFlags, mSource,
                         AMOTION_EVENT_ACTION_POINTER_UP, 0,
                         metaState, buttonState, AMOTION_EVENT_EDGE_FLAG_NONE,
                         mPointerGesture.lastGestureProperties,
-                        mPointerGesture.lastGestureCoords, mPointerGesture.lastGestureIdToIndex,
-                        dispatchedGestureIdBits, id,
+                        mPointerGesture.lastGestureCoords, mPointerGesture.lastGestureIds.count(),
+                        dispatchedGestureIds, upId,
                         0, 0, mPointerGesture.downTime);
 
-                dispatchedGestureIdBits.clearBit(id);
-            }
+                dispatchedGestureIds.remove(upId);
+            });
         }
     }
 
@@ -4311,30 +4307,29 @@
         dispatchMotion(when, policyFlags, mSource,
                 AMOTION_EVENT_ACTION_MOVE, 0, metaState, buttonState, AMOTION_EVENT_EDGE_FLAG_NONE,
                 mPointerGesture.currentGestureProperties,
-                mPointerGesture.currentGestureCoords, mPointerGesture.currentGestureIdToIndex,
-                dispatchedGestureIdBits, -1,
+                mPointerGesture.currentGestureCoords, mPointerGesture.currentGestureIds.count(),
+                dispatchedGestureIds, -1,
                 0, 0, mPointerGesture.downTime);
     }
 
     // Send motion events for all pointers that went down.
     if (down) {
-        BitSet32 downGestureIdBits(mPointerGesture.currentGestureIdBits.value
-                & ~dispatchedGestureIdBits.value);
-        while (!downGestureIdBits.isEmpty()) {
-            uint32_t id = downGestureIdBits.clearFirstMarkedBit();
-            dispatchedGestureIdBits.markBit(id);
-
-            if (dispatchedGestureIdBits.count() == 1) {
+        IntSet downGestureIds = mPointerGesture.currentGestureIds - dispatchedGestureIds;
+
+        downGestureIds.forEach([&](int32_t downId) {
+            dispatchedGestureIds.insert(downId);
+
+            if (dispatchedGestureIds.size() == 1) {
                 mPointerGesture.downTime = when;
             }
 
             dispatchMotion(when, policyFlags, mSource,
                     AMOTION_EVENT_ACTION_POINTER_DOWN, 0, metaState, buttonState, 0,
                     mPointerGesture.currentGestureProperties,
-                    mPointerGesture.currentGestureCoords, mPointerGesture.currentGestureIdToIndex,
-                    dispatchedGestureIdBits, id,
+                    mPointerGesture.currentGestureCoords, mPointerGesture.currentGestureIds.count(),
+                    dispatchedGestureIds, downId,
                     0, 0, mPointerGesture.downTime);
-        }
+        });
     }
 
     // Send motion events for hover.
@@ -4343,11 +4338,11 @@
                 AMOTION_EVENT_ACTION_HOVER_MOVE, 0,
                 metaState, buttonState, AMOTION_EVENT_EDGE_FLAG_NONE,
                 mPointerGesture.currentGestureProperties,
-                mPointerGesture.currentGestureCoords, mPointerGesture.currentGestureIdToIndex,
-                mPointerGesture.currentGestureIdBits, -1,
+                mPointerGesture.currentGestureCoords,
+                mPointerGesture.currentGestureIds.count(), -1,
                 0, 0, mPointerGesture.downTime);
-    } else if (dispatchedGestureIdBits.isEmpty()
-            && !mPointerGesture.lastGestureIdBits.isEmpty()) {
+    } else if (dispatchedGestureIds.isEmpty()
+            && !mPointerGesture.lastGestureIds.isEmpty()) {
         // Synthesize a hover move event after all pointers go up to indicate that
         // the pointer is hovering again even if the user is not currently touching
         // the touch pad.  This ensures that a view will receive a fresh hover enter
@@ -4375,32 +4370,29 @@
     // Update state.
     mPointerGesture.lastGestureMode = mPointerGesture.currentGestureMode;
     if (!down) {
-        mPointerGesture.lastGestureIdBits.clear();
+        mPointerGesture.lastGestureIds.clear();
     } else {
-        mPointerGesture.lastGestureIdBits = mPointerGesture.currentGestureIdBits;
-        for (BitSet32 idBits(mPointerGesture.currentGestureIdBits); !idBits.isEmpty(); ) {
-            uint32_t id = idBits.clearFirstMarkedBit();
-            uint32_t index = mPointerGesture.currentGestureIdToIndex[id];
+        mPointerGesture.lastGestureIds = mPointerGesture.currentGestureIds;
+        mPointerGesture.lastGestureIdToIndex = mPointerGesture.currentGestureIdToIndex;
+        for (uint32_t index = 0; index < mPointerGesture.currentGestureIds.count(); ++index) {
             mPointerGesture.lastGestureProperties[index].copyFrom(
                     mPointerGesture.currentGestureProperties[index]);
             mPointerGesture.lastGestureCoords[index].copyFrom(
                     mPointerGesture.currentGestureCoords[index]);
-            mPointerGesture.lastGestureIdToIndex[id] = index;
         }
     }
 }
 
 void TouchInputMapper::abortPointerGestures(nsecs_t when, uint32_t policyFlags) {
     // Cancel previously dispatches pointers.
-    if (!mPointerGesture.lastGestureIdBits.isEmpty()) {
+    if (!mPointerGesture.lastGestureIds.isEmpty()) {
         int32_t metaState = getContext()->getGlobalMetaState();
         int32_t buttonState = mCurrentButtonState;
         dispatchMotion(when, policyFlags, mSource,
                 AMOTION_EVENT_ACTION_CANCEL, 0, metaState, buttonState,
                 AMOTION_EVENT_EDGE_FLAG_NONE,
                 mPointerGesture.lastGestureProperties,
-                mPointerGesture.lastGestureCoords, mPointerGesture.lastGestureIdToIndex,
-                mPointerGesture.lastGestureIdBits, -1,
+                mPointerGesture.lastGestureCoords, mPointerGesture.lastGestureIds.count(), -1,
                 0, 0, mPointerGesture.downTime);
     }
 
@@ -4440,7 +4432,7 @@
 
                 mPointerGesture.activeGestureId = -1;
                 mPointerGesture.currentGestureMode = PointerGesture::NEUTRAL;
-                mPointerGesture.currentGestureIdBits.clear();
+                mPointerGesture.currentGestureIds.clear();
 
                 mPointerVelocityControl.reset();
                 return true;
@@ -4451,21 +4443,20 @@
         return false;
     }
 
-    const uint32_t currentFingerCount = mCurrentFingerIdBits.count();
-    const uint32_t lastFingerCount = mLastFingerIdBits.count();
+    const uint32_t currentFingerCount = mCurrentFingerIds.size();
+    const uint32_t lastFingerCount = mLastFingerIds.size();
 
     // Update the velocity tracker.
     {
         VelocityTracker::Position positions[MAX_POINTERS];
         uint32_t count = 0;
-        for (BitSet32 idBits(mCurrentFingerIdBits); !idBits.isEmpty(); count++) {
-            uint32_t id = idBits.clearFirstMarkedBit();
+        mCurrentFingerIds.forEach([&](int32_t id) {
             const RawPointerData::Pointer& pointer = mCurrentRawPointerData.pointerForId(id);
             positions[count].x = pointer.x * mPointerXMovementScale;
             positions[count].y = pointer.y * mPointerYMovementScale;
-        }
-        mPointerGesture.velocityTracker.addMovement(when,
-                mCurrentFingerIdBits, positions);
+            count++;
+        });
+        mPointerGesture.velocityTracker.addMovement(when, mCurrentFingerIds, positions);
     }
 
     // Pick a new active touch id if needed.
@@ -4477,17 +4468,17 @@
     int32_t lastActiveTouchId = mPointerGesture.activeTouchId;
     int32_t activeTouchId = lastActiveTouchId;
     if (activeTouchId < 0) {
-        if (!mCurrentFingerIdBits.isEmpty()) {
+        if (!mCurrentFingerIds.isEmpty()) {
             activeTouchChanged = true;
             activeTouchId = mPointerGesture.activeTouchId =
-                    mCurrentFingerIdBits.firstMarkedBit();
+                    mCurrentFingerIds.first();
             mPointerGesture.firstTouchTime = when;
         }
-    } else if (!mCurrentFingerIdBits.hasBit(activeTouchId)) {
+    } else if (!mCurrentFingerIds.contains(activeTouchId)) {
         activeTouchChanged = true;
-        if (!mCurrentFingerIdBits.isEmpty()) {
+        if (!mCurrentFingerIds.isEmpty()) {
             activeTouchId = mPointerGesture.activeTouchId =
-                    mCurrentFingerIdBits.firstMarkedBit();
+                    mCurrentFingerIds.first();
         } else {
             activeTouchId = mPointerGesture.activeTouchId = -1;
         }
@@ -4535,7 +4526,7 @@
 
         mPointerGesture.activeGestureId = -1;
         mPointerGesture.currentGestureMode = PointerGesture::QUIET;
-        mPointerGesture.currentGestureIdBits.clear();
+        mPointerGesture.currentGestureIds.clear();
 
         mPointerVelocityControl.reset();
     } else if (isPointerDown(mCurrentButtonState)) {
@@ -4567,8 +4558,7 @@
         if (activeTouchId >= 0 && currentFingerCount > 1) {
             int32_t bestId = -1;
             float bestSpeed = mConfig.pointerGestureDragMinSwitchSpeed;
-            for (BitSet32 idBits(mCurrentFingerIdBits); !idBits.isEmpty(); ) {
-                uint32_t id = idBits.clearFirstMarkedBit();
+            mCurrentFingerIds.forEach([&](int32_t id) {
                 float vx, vy;
                 if (mPointerGesture.velocityTracker.getVelocity(id, &vx, &vy)) {
                     float speed = hypotf(vx, vy);
@@ -4577,7 +4567,7 @@
                         bestSpeed = speed;
                     }
                 }
-            }
+            });
             if (bestId >= 0 && bestId != activeTouchId) {
                 mPointerGesture.activeTouchId = activeTouchId = bestId;
                 activeTouchChanged = true;
@@ -4588,7 +4578,7 @@
             }
         }
 
-        if (activeTouchId >= 0 && mLastFingerIdBits.hasBit(activeTouchId)) {
+        if (activeTouchId >= 0 && mLastFingerIds.contains(activeTouchId)) {
             const RawPointerData::Pointer& currentPointer =
                     mCurrentRawPointerData.pointerForId(activeTouchId);
             const RawPointerData::Pointer& lastPointer =
@@ -4611,9 +4601,8 @@
         mPointerController->getPosition(&x, &y);
 
         mPointerGesture.currentGestureMode = PointerGesture::BUTTON_CLICK_OR_DRAG;
-        mPointerGesture.currentGestureIdBits.clear();
-        mPointerGesture.currentGestureIdBits.markBit(mPointerGesture.activeGestureId);
-        mPointerGesture.currentGestureIdToIndex[mPointerGesture.activeGestureId] = 0;
+        mPointerGesture.currentGestureIds.clear();
+        mPointerGesture.currentGestureIds.insert(mPointerGesture.activeGestureId);
         mPointerGesture.currentGestureProperties[0].clear();
         mPointerGesture.currentGestureProperties[0].id = mPointerGesture.activeGestureId;
         mPointerGesture.currentGestureProperties[0].toolType = AMOTION_EVENT_TOOL_TYPE_FINGER;
@@ -4648,11 +4637,9 @@
 
                     mPointerGesture.activeGestureId = 0;
                     mPointerGesture.currentGestureMode = PointerGesture::TAP;
-                    mPointerGesture.currentGestureIdBits.clear();
-                    mPointerGesture.currentGestureIdBits.markBit(
+                    mPointerGesture.currentGestureIds.clear();
+                    mPointerGesture.currentGestureIds.insert(
                             mPointerGesture.activeGestureId);
-                    mPointerGesture.currentGestureIdToIndex[
-                            mPointerGesture.activeGestureId] = 0;
                     mPointerGesture.currentGestureProperties[0].clear();
                     mPointerGesture.currentGestureProperties[0].id =
                             mPointerGesture.activeGestureId;
@@ -4690,7 +4677,7 @@
 #endif
             mPointerGesture.activeGestureId = -1;
             mPointerGesture.currentGestureMode = PointerGesture::NEUTRAL;
-            mPointerGesture.currentGestureIdBits.clear();
+            mPointerGesture.currentGestureIds.clear();
         }
     } else if (currentFingerCount == 1) {
         // Case 4. Exactly one finger down, button is not pressed. (HOVER or TAP_DRAG)
@@ -4724,7 +4711,7 @@
             mPointerGesture.currentGestureMode = PointerGesture::TAP_DRAG;
         }
 
-        if (mLastFingerIdBits.hasBit(activeTouchId)) {
+        if (mLastFingerIds.contains(activeTouchId)) {
             const RawPointerData::Pointer& currentPointer =
                     mCurrentRawPointerData.pointerForId(activeTouchId);
             const RawPointerData::Pointer& lastPointer =
@@ -4764,9 +4751,8 @@
         float x, y;
         mPointerController->getPosition(&x, &y);
 
-        mPointerGesture.currentGestureIdBits.clear();
-        mPointerGesture.currentGestureIdBits.markBit(mPointerGesture.activeGestureId);
-        mPointerGesture.currentGestureIdToIndex[mPointerGesture.activeGestureId] = 0;
+        mPointerGesture.currentGestureIds.clear();
+        mPointerGesture.currentGestureIds.insert(mPointerGesture.activeGestureId);
         mPointerGesture.currentGestureProperties[0].clear();
         mPointerGesture.currentGestureProperties[0].id = mPointerGesture.activeGestureId;
         mPointerGesture.currentGestureProperties[0].toolType =
@@ -4823,7 +4809,7 @@
         if (*outFinishPreviousGesture || *outCancelPreviousGesture) {
             mPointerGesture.currentGestureMode = PointerGesture::PRESS;
             mPointerGesture.activeGestureId = 0;
-            mPointerGesture.referenceIdBits.clear();
+            mPointerGesture.referenceIds.clear();
             mPointerVelocityControl.reset();
 
             // Use the centroid and pointer location as the reference points for the gesture.
@@ -4841,21 +4827,18 @@
         }
 
         // Clear the reference deltas for fingers not yet included in the reference calculation.
-        for (BitSet32 idBits(mCurrentFingerIdBits.value
-                & ~mPointerGesture.referenceIdBits.value); !idBits.isEmpty(); ) {
-            uint32_t id = idBits.clearFirstMarkedBit();
+        (mCurrentFingerIds - mPointerGesture.referenceIds).forEach([&](int32_t id) {
             mPointerGesture.referenceDeltas[id].dx = 0;
             mPointerGesture.referenceDeltas[id].dy = 0;
-        }
-        mPointerGesture.referenceIdBits = mCurrentFingerIdBits;
+        });
+        mPointerGesture.referenceIds = mCurrentFingerIds;
 
         // Add delta for all fingers and calculate a common movement delta.
         float commonDeltaX = 0, commonDeltaY = 0;
-        BitSet32 commonIdBits(mLastFingerIdBits.value
-                & mCurrentFingerIdBits.value);
-        for (BitSet32 idBits(commonIdBits); !idBits.isEmpty(); ) {
-            bool first = (idBits == commonIdBits);
-            uint32_t id = idBits.clearFirstMarkedBit();
+        IntSet commonIds = mLastFingerIds & mCurrentFingerIds;
+
+        bool first = true;
+        commonIds.forEach([&](int32_t id) {
             const RawPointerData::Pointer& cpd = mCurrentRawPointerData.pointerForId(id);
             const RawPointerData::Pointer& lpd = mLastRawPointerData.pointerForId(id);
             PointerGesture::Delta& delta = mPointerGesture.referenceDeltas[id];
@@ -4865,25 +4848,25 @@
             if (first) {
                 commonDeltaX = delta.dx;
                 commonDeltaY = delta.dy;
+                first = false;
             } else {
                 commonDeltaX = calculateCommonVector(commonDeltaX, delta.dx);
                 commonDeltaY = calculateCommonVector(commonDeltaY, delta.dy);
             }
-        }
+        });
 
         // Consider transitions from PRESS to SWIPE or MULTITOUCH.
         if (mPointerGesture.currentGestureMode == PointerGesture::PRESS) {
-            float dist[MAX_POINTER_ID + 1];
+            std::unordered_map<int32_t, float> dist;
             int32_t distOverThreshold = 0;
-            for (BitSet32 idBits(mPointerGesture.referenceIdBits); !idBits.isEmpty(); ) {
-                uint32_t id = idBits.clearFirstMarkedBit();
+            mPointerGesture.referenceIds.forEach([&](int32_t id) {
                 PointerGesture::Delta& delta = mPointerGesture.referenceDeltas[id];
                 dist[id] = hypotf(delta.dx * mPointerXZoomScale,
                         delta.dy * mPointerYZoomScale);
                 if (dist[id] > mConfig.pointerGestureMultitouchMinDistance) {
                     distOverThreshold += 1;
                 }
-            }
+            });
 
             // Only transition when at least two pointers have moved further than
             // the minimum distance threshold.
@@ -4898,9 +4881,14 @@
                     mPointerGesture.currentGestureMode = PointerGesture::FREEFORM;
                 } else {
                     // There are exactly two pointers.
-                    BitSet32 idBits(mCurrentFingerIdBits);
-                    uint32_t id1 = idBits.clearFirstMarkedBit();
-                    uint32_t id2 = idBits.firstMarkedBit();
+                    int32_t id1;
+                    int32_t id2;
+                    {
+                        auto currentFingerIdsIt = mCurrentFingerIds.cbegin();
+                        id1 = *currentFingerIdsIt;
+                        ++currentFingerIdsIt;
+                        id2 = *currentFingerIdsIt;
+                    }
                     const RawPointerData::Pointer& p1 = mCurrentRawPointerData.pointerForId(id1);
                     const RawPointerData::Pointer& p2 = mCurrentRawPointerData.pointerForId(id2);
                     float mutualDistance = distance(p1.x, p1.y, p2.x, p2.y);
@@ -4977,12 +4965,11 @@
         // except in PRESS mode while waiting for a transition to occur.
         if (mPointerGesture.currentGestureMode != PointerGesture::PRESS
                 && (commonDeltaX || commonDeltaY)) {
-            for (BitSet32 idBits(mPointerGesture.referenceIdBits); !idBits.isEmpty(); ) {
-                uint32_t id = idBits.clearFirstMarkedBit();
+            mPointerGesture.referenceIds.forEach([&](int32_t id) {
                 PointerGesture::Delta& delta = mPointerGesture.referenceDeltas[id];
                 delta.dx = 0;
                 delta.dy = 0;
-            }
+            });
 
             mPointerGesture.referenceTouchX += commonDeltaX;
             mPointerGesture.referenceTouchY += commonDeltaY;
@@ -5008,9 +4995,8 @@
 #endif
             ALOG_ASSERT(mPointerGesture.activeGestureId >= 0);
 
-            mPointerGesture.currentGestureIdBits.clear();
-            mPointerGesture.currentGestureIdBits.markBit(mPointerGesture.activeGestureId);
-            mPointerGesture.currentGestureIdToIndex[mPointerGesture.activeGestureId] = 0;
+            mPointerGesture.currentGestureIds.clear();
+            mPointerGesture.currentGestureIds.insert(mPointerGesture.activeGestureId);
             mPointerGesture.currentGestureProperties[0].clear();
             mPointerGesture.currentGestureProperties[0].id = mPointerGesture.activeGestureId;
             mPointerGesture.currentGestureProperties[0].toolType =
@@ -5030,16 +5016,16 @@
 #endif
             ALOG_ASSERT(mPointerGesture.activeGestureId >= 0);
 
-            mPointerGesture.currentGestureIdBits.clear();
+            mPointerGesture.currentGestureIds.clear();
 
-            BitSet32 mappedTouchIdBits;
-            BitSet32 usedGestureIdBits;
+            IntSet mappedTouchIds;
+            IntSet usedGestureIds;
             if (mPointerGesture.lastGestureMode != PointerGesture::FREEFORM) {
                 // Initially, assign the active gesture id to the active touch point
                 // if there is one.  No other touch id bits are mapped yet.
                 if (!*outCancelPreviousGesture) {
-                    mappedTouchIdBits.markBit(activeTouchId);
-                    usedGestureIdBits.markBit(mPointerGesture.activeGestureId);
+                    mappedTouchIds.insert(activeTouchId);
+                    usedGestureIds.insert(mPointerGesture.activeGestureId);
                     mPointerGesture.freeformTouchToGestureIdMap[activeTouchId] =
                             mPointerGesture.activeGestureId;
                 } else {
@@ -5048,38 +5034,41 @@
             } else {
                 // Otherwise, assume we mapped all touches from the previous frame.
                 // Reuse all mappings that are still applicable.
-                mappedTouchIdBits.value = mLastFingerIdBits.value
-                        & mCurrentFingerIdBits.value;
-                usedGestureIdBits = mPointerGesture.lastGestureIdBits;
+                mappedTouchIds = mLastFingerIds & mCurrentFingerIds;
+                usedGestureIds = mPointerGesture.lastGestureIds;
 
                 // Check whether we need to choose a new active gesture id because the
                 // current went went up.
-                for (BitSet32 upTouchIdBits(mLastFingerIdBits.value
-                        & ~mCurrentFingerIdBits.value);
-                        !upTouchIdBits.isEmpty(); ) {
-                    uint32_t upTouchId = upTouchIdBits.clearFirstMarkedBit();
-                    uint32_t upGestureId = mPointerGesture.freeformTouchToGestureIdMap[upTouchId];
-                    if (upGestureId == uint32_t(mPointerGesture.activeGestureId)) {
-                        mPointerGesture.activeGestureId = -1;
-                        break;
+                auto it = mLastFingerIds.cbegin();
+                while (it != mLastFingerIds.cend()) {
+                    int32_t id = *it;
+                    if (!mCurrentFingerIds.contains(id)) {
+                        int32_t upGestureId = mPointerGesture.freeformTouchToGestureIdMap[id];
+                        if (upGestureId == mPointerGesture.activeGestureId) {
+                            mPointerGesture.activeGestureId = -1;
+                            break;
+                        }
                     }
+                    it++;
                 }
             }
 
 #if DEBUG_GESTURES
-            ALOGD("Gestures: FREEFORM follow up "
-                    "mappedTouchIdBits=0x%08x, usedGestureIdBits=0x%08x, "
-                    "activeGestureId=%d",
-                    mappedTouchIdBits.value, usedGestureIdBits.value,
-                    mPointerGesture.activeGestureId);
+            {
+                std::string mappedTouchIdsString = mappedTouchIdBits.toString();
+                std::string usedGestureIdsString = usedGestureIdBits.toString();
+                ALOGD("Gestures: FREEFORM follow up "
+                        "mappedTouchIds=%s, usedGestureIds=%s, "
+                        "activeGestureId=%d",
+                        mappedTouchIdsString.c_str(), usedGestureIdsString.c_str(),
+                        mPointerGesture.activeGestureId);
+            }
 #endif
-
-            BitSet32 idBits(mCurrentFingerIdBits);
-            for (uint32_t i = 0; i < currentFingerCount; i++) {
-                uint32_t touchId = idBits.clearFirstMarkedBit();
-                uint32_t gestureId;
-                if (!mappedTouchIdBits.hasBit(touchId)) {
-                    gestureId = usedGestureIdBits.markFirstUnmarkedBit();
+            uint32_t i = 0;
+            mCurrentFingerIds.forEach([&](int32_t touchId) {
+                int32_t gestureId;
+                if (mappedTouchIds.contains(touchId)) {
+                    gestureId = usedGestureIds.first();
                     mPointerGesture.freeformTouchToGestureIdMap[touchId] = gestureId;
 #if DEBUG_GESTURES
                     ALOGD("Gestures: FREEFORM "
@@ -5094,8 +5083,7 @@
                             touchId, gestureId);
 #endif
                 }
-                mPointerGesture.currentGestureIdBits.markBit(gestureId);
-                mPointerGesture.currentGestureIdToIndex[gestureId] = i;
+                mPointerGesture.currentGestureIds.insert(gestureId);
 
                 const RawPointerData::Pointer& pointer =
                         mCurrentRawPointerData.pointerForId(touchId);
@@ -5116,11 +5104,12 @@
                         AMOTION_EVENT_AXIS_Y, mPointerGesture.referenceGestureY + deltaY);
                 mPointerGesture.currentGestureCoords[i].setAxisValue(
                         AMOTION_EVENT_AXIS_PRESSURE, 1.0f);
-            }
+
+                ++i;
+            });
 
             if (mPointerGesture.activeGestureId < 0) {
-                mPointerGesture.activeGestureId =
-                        mPointerGesture.currentGestureIdBits.firstMarkedBit();
+                mPointerGesture.activeGestureId = mPointerGesture.currentGestureIds.first();
 #if DEBUG_GESTURES
                 ALOGD("Gestures: FREEFORM new "
                         "activeGestureId=%d", mPointerGesture.activeGestureId);
@@ -5132,35 +5121,35 @@
     mPointerController->setButtonState(mCurrentButtonState);
 
 #if DEBUG_GESTURES
-    ALOGD("Gestures: finishPreviousGesture=%s, cancelPreviousGesture=%s, "
-            "currentGestureMode=%d, currentGestureIdBits=0x%08x, "
-            "lastGestureMode=%d, lastGestureIdBits=0x%08x",
-            toString(*outFinishPreviousGesture), toString(*outCancelPreviousGesture),
-            mPointerGesture.currentGestureMode, mPointerGesture.currentGestureIdBits.value,
-            mPointerGesture.lastGestureMode, mPointerGesture.lastGestureIdBits.value);
-    for (BitSet32 idBits = mPointerGesture.currentGestureIdBits; !idBits.isEmpty(); ) {
-        uint32_t id = idBits.clearFirstMarkedBit();
-        uint32_t index = mPointerGesture.currentGestureIdToIndex[id];
-        const PointerProperties& properties = mPointerGesture.currentGestureProperties[index];
-        const PointerCoords& coords = mPointerGesture.currentGestureCoords[index];
-        ALOGD("  currentGesture[%d]: index=%d, toolType=%d, "
-                "x=%0.3f, y=%0.3f, pressure=%0.3f",
-                id, index, properties.toolType,
-                coords.getAxisValue(AMOTION_EVENT_AXIS_X),
-                coords.getAxisValue(AMOTION_EVENT_AXIS_Y),
-                coords.getAxisValue(AMOTION_EVENT_AXIS_PRESSURE));
-    }
-    for (BitSet32 idBits = mPointerGesture.lastGestureIdBits; !idBits.isEmpty(); ) {
-        uint32_t id = idBits.clearFirstMarkedBit();
-        uint32_t index = mPointerGesture.lastGestureIdToIndex[id];
-        const PointerProperties& properties = mPointerGesture.lastGestureProperties[index];
-        const PointerCoords& coords = mPointerGesture.lastGestureCoords[index];
-        ALOGD("  lastGesture[%d]: index=%d, toolType=%d, "
-                "x=%0.3f, y=%0.3f, pressure=%0.3f",
-                id, index, properties.toolType,
-                coords.getAxisValue(AMOTION_EVENT_AXIS_X),
-                coords.getAxisValue(AMOTION_EVENT_AXIS_Y),
-                coords.getAxisValue(AMOTION_EVENT_AXIS_PRESSURE));
+    {
+        std::string lastGestureIdsString = mPointerGesture.lastGestureIds.toString();
+
+        ALOGD("Gestures: finishPreviousGesture=%s, cancelPreviousGesture=%s, "
+                "currentGestureMode=%d, currentGestureIds.count()=%u, "
+                "lastGestureMode=%d, lastGestureIds=%s",
+                toString(*outFinishPreviousGesture), toString(*outCancelPreviousGesture),
+                mPointerGesture.currentGestureMode, mPointerGesture.currentGestureIds.count(),
+                mPointerGesture.lastGestureMode, lastGestureIdsString.c_str());
+        for (uint32_t index = 0; index < mPointerGesture.currentGestureIds.count(); ++index) {
+            const PointerProperties& properties = mPointerGesture.currentGestureProperties[index];
+            const PointerCoords& coords = mPointerGesture.currentGestureCoords[index];
+            ALOGD("  currentGesture[%d]: index=%d, toolType=%d, "
+                    "x=%0.3f, y=%0.3f, pressure=%0.3f",
+                    id, index, properties.toolType,
+                    coords.getAxisValue(AMOTION_EVENT_AXIS_X),
+                    coords.getAxisValue(AMOTION_EVENT_AXIS_Y),
+                    coords.getAxisValue(AMOTION_EVENT_AXIS_PRESSURE));
+        }
+        for (uint32_t index = 0; index < mPointerGesture.lastGestureIds.count(); ++index) {
+            const PointerProperties& properties = mPointerGesture.lastGestureProperties[index];
+            const PointerCoords& coords = mPointerGesture.lastGestureCoords[index];
+            ALOGD("  lastGesture[%d]: index=%d, toolType=%d, "
+                    "x=%0.3f, y=%0.3f, pressure=%0.3f",
+                    id, index, properties.toolType,
+                    coords.getAxisValue(AMOTION_EVENT_AXIS_X),
+                    coords.getAxisValue(AMOTION_EVENT_AXIS_Y),
+                    coords.getAxisValue(AMOTION_EVENT_AXIS_PRESSURE));
+        }
     }
 #endif
     return true;
@@ -5171,14 +5160,14 @@
     mPointerSimple.currentProperties.clear();
 
     bool down, hovering;
-    if (!mCurrentStylusIdBits.isEmpty()) {
-        uint32_t id = mCurrentStylusIdBits.firstMarkedBit();
-        uint32_t index = mCurrentCookedPointerData.idToIndex[id];
+    if (!mCurrentStylusIds.isEmpty()) {
+        int32_t id = mCurrentStylusIds.first();
+        uint32_t index = mCurrentCookedPointerData.idToIndex(id);
         float x = mCurrentCookedPointerData.pointerCoords[index].getX();
         float y = mCurrentCookedPointerData.pointerCoords[index].getY();
         mPointerController->setPosition(x, y);
 
-        hovering = mCurrentCookedPointerData.hoveringIdBits.hasBit(id);
+        hovering = mCurrentCookedPointerData.hoveringIds.contains(id);
         down = !hovering;
 
         mPointerController->getPosition(&x, &y);
@@ -5205,11 +5194,11 @@
     mPointerSimple.currentProperties.clear();
 
     bool down, hovering;
-    if (!mCurrentMouseIdBits.isEmpty()) {
-        uint32_t id = mCurrentMouseIdBits.firstMarkedBit();
-        uint32_t currentIndex = mCurrentRawPointerData.idToIndex[id];
-        if (mLastMouseIdBits.hasBit(id)) {
-            uint32_t lastIndex = mCurrentRawPointerData.idToIndex[id];
+    if (!mCurrentMouseIds.isEmpty()) {
+        uint32_t id = mCurrentMouseIds.first();
+        uint32_t currentIndex = mCurrentRawPointerData.idToIndex(id);
+        if (mLastMouseIds.contains(id)) {
+            uint32_t lastIndex = mCurrentRawPointerData.idToIndex(id);
             float deltaX = (mCurrentRawPointerData.pointers[currentIndex].x
                     - mLastRawPointerData.pointers[lastIndex].x)
                     * mPointerXMovementScale;
@@ -5377,19 +5366,17 @@
 
 void TouchInputMapper::dispatchMotion(nsecs_t when, uint32_t policyFlags, uint32_t source,
         int32_t action, int32_t flags, int32_t metaState, int32_t buttonState, int32_t edgeFlags,
-        const PointerProperties* properties, const PointerCoords* coords,
-        const uint32_t* idToIndex, BitSet32 idBits,
+        const PointerProperties* properties, const PointerCoords* coords, uint32_t inPointerCount,
         int32_t changedId, float xPrecision, float yPrecision, nsecs_t downTime) {
     PointerCoords pointerCoords[MAX_POINTERS];
     PointerProperties pointerProperties[MAX_POINTERS];
     uint32_t pointerCount = 0;
-    while (!idBits.isEmpty()) {
-        uint32_t id = idBits.clearFirstMarkedBit();
-        uint32_t index = idToIndex[id];
-        pointerProperties[pointerCount].copyFrom(properties[index]);
-        pointerCoords[pointerCount].copyFrom(coords[index]);
-
-        if (changedId >= 0 && id == uint32_t(changedId)) {
+
+    while (pointerCount < inPointerCount) {
+        pointerProperties[pointerCount].copyFrom(properties[pointerCount]);
+        pointerCoords[pointerCount].copyFrom(coords[pointerCount]);
+
+        if (changedId >= 0 && properties[pointerCount].id == uint32_t(changedId)) {
             action |= pointerCount << AMOTION_EVENT_ACTION_POINTER_INDEX_SHIFT;
         }
 
@@ -5418,31 +5405,94 @@
     getListener()->notifyMotion(&args);
 }
 
+void TouchInputMapper::dispatchMotion(nsecs_t when, uint32_t policyFlags, uint32_t source,
+        int32_t action, int32_t flags, int32_t metaState, int32_t buttonState, int32_t edgeFlags,
+        const PointerProperties* properties, const PointerCoords* coords,
+        uint32_t inPointerCount, const IntSet &idsToDispatch,
+        int32_t changedId, float xPrecision, float yPrecision, nsecs_t downTime) {
+    PointerCoords pointerCoords[MAX_POINTERS];
+    PointerProperties pointerProperties[MAX_POINTERS];
+    uint32_t pointerCount = 0;
+
+    for (uint32_t i = 0; i < inPointerCount && pointerCount < idsToDispatch.size(); ++i) {
+        if (!idsToDispatch.contains(properties[i].id))
+            continue;
+
+        pointerProperties[pointerCount].copyFrom(properties[i]);
+        pointerCoords[pointerCount].copyFrom(coords[i]);
+
+        if (changedId >= 0 && properties[i].id == uint32_t(changedId)) {
+            action |= i << AMOTION_EVENT_ACTION_POINTER_INDEX_SHIFT;
+        }
+
+        pointerCount += 1;
+    }
+
+    ALOG_ASSERT(pointerCount != 0);
+
+    if (changedId >= 0 && pointerCount == 1) {
+        // Remove the poiter index part
+        int actionPart = action & AMOTION_EVENT_ACTION_MASK;
+
+        // Replace initial down and final up action.
+        // We can compare the action without masking off the changed pointer index
+        // because we know the index is 0.
+        if (actionPart == AMOTION_EVENT_ACTION_POINTER_DOWN) {
+            actionPart = AMOTION_EVENT_ACTION_DOWN;
+        } else if (actionPart & AMOTION_EVENT_ACTION_POINTER_UP) {
+            actionPart = AMOTION_EVENT_ACTION_UP;
+        } else {
+            // Can't happen.
+            ALOG_ASSERT(false);
+        }
+
+        // And put it back into the action integer
+        action = (action & AMOTION_EVENT_ACTION_POINTER_INDEX_MASK) | actionPart;
+    }
+
+    NotifyMotionArgs args(when, getDeviceId(), source, policyFlags,
+            action, flags, metaState, buttonState, edgeFlags,
+            pointerCount, pointerProperties, pointerCoords, xPrecision, yPrecision, downTime);
+    getListener()->notifyMotion(&args);
+}
+
 bool TouchInputMapper::updateMovedPointers(const PointerProperties* inProperties,
-        const PointerCoords* inCoords, const uint32_t* inIdToIndex,
-        PointerProperties* outProperties, PointerCoords* outCoords, const uint32_t* outIdToIndex,
-        BitSet32 idBits) const {
+        const PointerCoords* inCoords, uint32_t inPointerCount,
+        PointerProperties* outProperties, PointerCoords* outCoords, uint32_t outPointerCount,
+        const IntSet &commonTouchingIds) const {
     bool changed = false;
-    while (!idBits.isEmpty()) {
-        uint32_t id = idBits.clearFirstMarkedBit();
-        uint32_t inIndex = inIdToIndex[id];
-        uint32_t outIndex = outIdToIndex[id];
-
-        const PointerProperties& curInProperties = inProperties[inIndex];
-        const PointerCoords& curInCoords = inCoords[inIndex];
-        PointerProperties& curOutProperties = outProperties[outIndex];
-        PointerCoords& curOutCoords = outCoords[outIndex];
-
-        if (curInProperties != curOutProperties) {
-            curOutProperties.copyFrom(curInProperties);
-            changed = true;
-        }
-
-        if (curInCoords != curOutCoords) {
-            curOutCoords.copyFrom(curInCoords);
-            changed = true;
-        }
-    }
+
+    if (commonTouchingIds.isEmpty()) {
+        return changed;
+    }
+
+    for (uint32_t inIndex = 0; inIndex < inPointerCount; ++inIndex) {
+        int32_t inId = inProperties[inIndex].id;
+        if (!commonTouchingIds.contains(inId)) {
+            continue;
+        }
+        for (uint32_t outIndex = 0; outIndex < outPointerCount; ++outIndex) {
+            int32_t outId = outProperties[outIndex].id;
+            if (inId == outId) {
+                // The pointer is present in both sets. Let's see if it has moved.
+                const PointerProperties& curInProperties = inProperties[inIndex];
+                const PointerCoords& curInCoords = inCoords[inIndex];
+                PointerProperties& curOutProperties = outProperties[outIndex];
+                PointerCoords& curOutCoords = outCoords[outIndex];
+
+                if (curInProperties != curOutProperties) {
+                    curOutProperties.copyFrom(curInProperties);
+                    changed = true;
+                }
+
+                if (curInCoords != curOutCoords) {
+                    curOutCoords.copyFrom(curInCoords);
+                    changed = true;
+                }
+            }
+        }
+    }
+
     return changed;
 }
 
@@ -5484,7 +5534,7 @@
     uint32_t currentPointerCount = mCurrentRawPointerData.pointerCount;
     uint32_t lastPointerCount = mLastRawPointerData.pointerCount;
 
-    mCurrentRawPointerData.clearIdBits();
+    mCurrentRawPointerData.clearIds();
 
     if (currentPointerCount == 0) {
         // No pointers to assign.
@@ -5494,10 +5544,9 @@
     if (lastPointerCount == 0) {
         // All pointers are new.
         for (uint32_t i = 0; i < currentPointerCount; i++) {
-            uint32_t id = i;
+            int32_t id = fetchNewPointerId();
             mCurrentRawPointerData.pointers[i].id = id;
-            mCurrentRawPointerData.idToIndex[id] = i;
-            mCurrentRawPointerData.markIdBit(id, mCurrentRawPointerData.isHovering(i));
+            mCurrentRawPointerData.insertId(id, mCurrentRawPointerData.isHovering(i));
         }
         return;
     }
@@ -5506,10 +5555,9 @@
             && mCurrentRawPointerData.pointers[0].toolType
                     == mLastRawPointerData.pointers[0].toolType) {
         // Only one pointer and no change in count so it must have the same id as before.
-        uint32_t id = mLastRawPointerData.pointers[0].id;
+        int32_t id = mLastRawPointerData.pointers[0].id;
         mCurrentRawPointerData.pointers[0].id = id;
-        mCurrentRawPointerData.idToIndex[id] = 0;
-        mCurrentRawPointerData.markIdBit(id, mCurrentRawPointerData.isHovering(0));
+        mCurrentRawPointerData.insertId(id, mCurrentRawPointerData.isHovering(0));
         return;
     }
 
@@ -5569,9 +5617,9 @@
     }
 
 #if DEBUG_POINTER_ASSIGNMENT
-    ALOGD("assignPointerIds - initial distance min-heap: size=%d", heapSize);
+    ALOGD("assignPointerIds - initial distance min-heap: size=%u", heapSize);
     for (size_t i = 0; i < heapSize; i++) {
-        ALOGD("  heap[%d]: cur=%d, last=%d, distance=%lld",
+        ALOGD("  heap[%d]: cur=%u, last=%u, distance=%llu",
                 i, heap[i].currentPointerIndex, heap[i].lastPointerIndex,
                 heap[i].distance);
     }
@@ -5580,10 +5628,8 @@
     // Pull matches out by increasing order of distance.
     // To avoid reassigning pointers that have already been matched, the loop keeps track
     // of which last and current pointers have been matched using the matchedXXXBits variables.
-    // It also tracks the used pointer id bits.
     BitSet32 matchedLastBits(0);
     BitSet32 matchedCurrentBits(0);
-    BitSet32 usedIdBits(0);
     bool first = true;
     for (uint32_t i = min(currentPointerCount, lastPointerCount); heapSize > 0 && i > 0; i--) {
         while (heapSize > 0) {
@@ -5635,12 +5681,9 @@
             matchedCurrentBits.markBit(currentPointerIndex);
             matchedLastBits.markBit(lastPointerIndex);
 
-            uint32_t id = mLastRawPointerData.pointers[lastPointerIndex].id;
+            int32_t id = mLastRawPointerData.pointers[lastPointerIndex].id;
             mCurrentRawPointerData.pointers[currentPointerIndex].id = id;
-            mCurrentRawPointerData.idToIndex[id] = currentPointerIndex;
-            mCurrentRawPointerData.markIdBit(id,
-                    mCurrentRawPointerData.isHovering(currentPointerIndex));
-            usedIdBits.markBit(id);
+            mCurrentRawPointerData.insertId(id, mCurrentRawPointerData.isHovering(currentPointerIndex));
 
 #if DEBUG_POINTER_ASSIGNMENT
             ALOGD("assignPointerIds - matched: cur=%d, last=%d, id=%d, distance=%lld",
@@ -5653,11 +5696,10 @@
     // Assign fresh ids to pointers that were not matched in the process.
     for (uint32_t i = currentPointerCount - matchedCurrentBits.count(); i != 0; i--) {
         uint32_t currentPointerIndex = matchedCurrentBits.markFirstUnmarkedBit();
-        uint32_t id = usedIdBits.markFirstUnmarkedBit();
+        int32_t id = fetchNewPointerId();
 
         mCurrentRawPointerData.pointers[currentPointerIndex].id = id;
-        mCurrentRawPointerData.idToIndex[id] = currentPointerIndex;
-        mCurrentRawPointerData.markIdBit(id,
+        mCurrentRawPointerData.insertId(id,
                 mCurrentRawPointerData.isHovering(currentPointerIndex));
 
 #if DEBUG_POINTER_ASSIGNMENT
@@ -5667,6 +5709,14 @@
     }
 }
 
+int32_t TouchInputMapper::fetchNewPointerId() {
+    int32_t id = mNextNewPointerId++;
+    if (mNextNewPointerId > MAX_POINTER_ID) {
+        mNextNewPointerId = 0;
+    }
+    return id;
+}
+
 int32_t TouchInputMapper::getKeyCodeState(uint32_t sourceMask, int32_t keyCode) {
     if (mCurrentVirtualKey.down && mCurrentVirtualKey.keyCode == keyCode) {
         return AKEY_STATE_VIRTUAL;
@@ -5740,16 +5790,21 @@
 void SingleTouchInputMapper::syncTouch(nsecs_t when, bool* outHavePointerIds) {
     if (mTouchButtonAccumulator.isToolActive()) {
         mCurrentRawPointerData.pointerCount = 1;
-        mCurrentRawPointerData.idToIndex[0] = 0;
 
         bool isHovering = mTouchButtonAccumulator.getToolType() != AMOTION_EVENT_TOOL_TYPE_MOUSE
                 && (mTouchButtonAccumulator.isHovering()
                         || (mRawPointerAxes.pressure.valid
                                 && mSingleTouchMotionAccumulator.getAbsolutePressure() <= 0));
-        mCurrentRawPointerData.markIdBit(0, isHovering);
 
         RawPointerData::Pointer& outPointer = mCurrentRawPointerData.pointers[0];
-        outPointer.id = 0;
+
+        if (mLastRawPointerData.pointerCount == 1) {
+            outPointer.id = mLastRawPointerData.pointers[0].id;
+            mCurrentRawPointerData.insertId(outPointer.id, isHovering);
+        } else {
+            outPointer.id = -1;
+            *outHavePointerIds = false;
+        }
         outPointer.x = mSingleTouchMotionAccumulator.getAbsoluteX();
         outPointer.y = mSingleTouchMotionAccumulator.getAbsoluteY();
         outPointer.pressure = mSingleTouchMotionAccumulator.getAbsolutePressure();
@@ -5766,6 +5821,7 @@
             outPointer.toolType = AMOTION_EVENT_TOOL_TYPE_FINGER;
         }
         outPointer.isHovering = isHovering;
+
     }
 }
 
@@ -5798,7 +5854,7 @@
 void MultiTouchInputMapper::reset(nsecs_t when) {
     mMultiTouchMotionAccumulator.reset(getDevice());
 
-    mPointerIdBits.clear();
+    mPointerIds.clear();
 
     TouchInputMapper::reset(when);
 }
@@ -5812,7 +5868,7 @@
 void MultiTouchInputMapper::syncTouch(nsecs_t when, bool* outHavePointerIds) {
     size_t inCount = mMultiTouchMotionAccumulator.getSlotCount();
     size_t outCount = 0;
-    BitSet32 newPointerIdBits;
+    IntSet newPointerIds;
 
     for (size_t inIndex = 0; inIndex < inCount; inIndex++) {
         const MultiTouchMotionAccumulator::Slot* inSlot =
@@ -5861,27 +5917,26 @@
             int32_t trackingId = inSlot->getTrackingId();
             int32_t id = -1;
             if (trackingId >= 0) {
-                for (BitSet32 idBits(mPointerIdBits); !idBits.isEmpty(); ) {
-                    uint32_t n = idBits.clearFirstMarkedBit();
+                mPointerIds.forEach([&](int32_t n) {
                     if (mPointerTrackingIdMap[n] == trackingId) {
                         id = n;
                     }
-                }
+                });
 
-                if (id < 0 && !mPointerIdBits.isFull()) {
-                    id = mPointerIdBits.markFirstUnmarkedBit();
+                if (id < 0) {
+                    id = fetchNewPointerId();
+                    mPointerIds.insert(id);
                     mPointerTrackingIdMap[id] = trackingId;
                 }
             }
             if (id < 0) {
                 *outHavePointerIds = false;
-                mCurrentRawPointerData.clearIdBits();
-                newPointerIdBits.clear();
+                mCurrentRawPointerData.clearIds();
+                newPointerIds.clear();
             } else {
                 outPointer.id = id;
-                mCurrentRawPointerData.idToIndex[id] = outCount;
-                mCurrentRawPointerData.markIdBit(id, isHovering);
-                newPointerIdBits.markBit(id);
+                mCurrentRawPointerData.insertId(id, isHovering);
+                newPointerIds.insert(id);
             }
         }
 
@@ -5889,7 +5944,7 @@
     }
 
     mCurrentRawPointerData.pointerCount = outCount;
-    mPointerIdBits = newPointerIdBits;
+    mPointerIds = newPointerIds;
 
     mMultiTouchMotionAccumulator.finishSync();
 }
@@ -5914,8 +5969,8 @@
             && mRawPointerAxes.slot.minValue == 0 && mRawPointerAxes.slot.maxValue > 0) {
         size_t slotCount = mRawPointerAxes.slot.maxValue + 1;
         if (slotCount > MAX_SLOTS) {
-            ALOGW("MultiTouch Device %s reported %d slots but the framework "
-                    "only supports a maximum of %d slots at this time.",
+            ALOGW("MultiTouch Device %s reported %lu slots but the framework "
+                    "only supports a maximum of %lu slots at this time.",
                     c_str(getDeviceName()), slotCount, MAX_SLOTS);
             slotCount = MAX_SLOTS;
         }
@@ -6057,7 +6112,7 @@
         // If there are too many axes, start dropping them.
         // Prefer to keep explicitly mapped axes.
         if (mAxes.size() > PointerCoords::MAX_AXES) {
-            ALOGI("Joystick '%s' has %d axes but the framework only supports a maximum of %d.",
+            ALOGI("Joystick '%s' has %lu axes but the framework only supports a maximum of %d.",
                 c_str(getDeviceName()), mAxes.size(), PointerCoords::MAX_AXES);
             pruneAxes(true);
             pruneAxes(false);

=== modified file '3rd_party/android-input/android/frameworks/base/services/input/InputReader.h'
--- 3rd_party/android-input/android/frameworks/base/services/input/InputReader.h	2013-09-20 12:18:12 +0000
+++ 3rd_party/android-input/android/frameworks/base/services/input/InputReader.h	2013-11-25 03:07:43 +0000
@@ -22,6 +22,7 @@
 #include "InputListener.h"
 
 #include <androidfw/Input.h>
+#include <androidfw/IntSet.h>
 #include <androidfw/VelocityControl.h>
 #include <androidfw/VelocityTracker.h>
 #include <std/KeyedVector.h>
@@ -30,12 +31,14 @@
 #include <std/Timers.h>
 #include <std/RefBase.h>
 #include <std/String8.h>
-#include <std/BitSet.h>
 
 #include <limits.h>
 #include <stddef.h>
 #include <unistd.h>
 
+// C++ std lib
+#include <unordered_map>
+
 // Maximum supported size of a vibration pattern.
 // Must be at least 2.
 #define MAX_VIBRATE_PATTERN_SIZE 100
@@ -678,7 +681,7 @@
 /* Raw data for a collection of pointers including a pointer id mapping table. */
 struct RawPointerData {
     struct Pointer {
-        uint32_t id;
+        int32_t id;
         int32_t x;
         int32_t y;
         int32_t pressure;
@@ -696,29 +699,40 @@
 
     uint32_t pointerCount;
     Pointer pointers[MAX_POINTERS];
-    BitSet32 hoveringIdBits, touchingIdBits;
-    uint32_t idToIndex[MAX_POINTER_ID + 1];
+    IntSet hoveringIds, touchingIds;
+
+    uint32_t idToIndex(int32_t id) const {
+        uint32_t i = 0;
+
+        while (pointers[i].id != id && i < pointerCount) {
+            ++i;
+        }
+
+        assert(pointers[i].id == id);
+        return i;
+    }
+
 
     RawPointerData();
     void clear();
     void copyFrom(const RawPointerData& other);
     void getCentroidOfTouchingPointers(float* outX, float* outY) const;
 
-    inline void markIdBit(uint32_t id, bool isHovering) {
+    inline void insertId(int32_t id, bool isHovering) {
         if (isHovering) {
-            hoveringIdBits.markBit(id);
+            hoveringIds.insert(id);
         } else {
-            touchingIdBits.markBit(id);
+            touchingIds.insert(id);
         }
     }
 
-    inline void clearIdBits() {
-        hoveringIdBits.clear();
-        touchingIdBits.clear();
+    inline void clearIds() {
+        hoveringIds.clear();
+        touchingIds.clear();
     }
 
-    inline const Pointer& pointerForId(uint32_t id) const {
-        return pointers[idToIndex[id]];
+    inline const Pointer& pointerForId(int32_t id) const {
+        return pointers[idToIndex(id)];
     }
 
     inline bool isHovering(uint32_t pointerIndex) {
@@ -732,15 +746,22 @@
     uint32_t pointerCount;
     PointerProperties pointerProperties[MAX_POINTERS];
     PointerCoords pointerCoords[MAX_POINTERS];
-    BitSet32 hoveringIdBits, touchingIdBits;
-    uint32_t idToIndex[MAX_POINTER_ID + 1];
+    IntSet hoveringIds, touchingIds;
+    uint32_t idToIndex(int32_t id) const {
+        uint32_t i = 0;
+
+        while (pointerProperties[i].id != id && i < pointerCount) { ++i; }
+
+        assert(pointerProperties[i].id == id);
+        return i;
+    }
 
     CookedPointerData();
     void clear();
     void copyFrom(const CookedPointerData& other);
 
     inline bool isHovering(uint32_t pointerIndex) {
-        return hoveringIdBits.hasBit(pointerProperties[pointerIndex].id);
+        return hoveringIds.contains(pointerProperties[pointerIndex].id);
     }
 };
 
@@ -1233,13 +1254,13 @@
     int32_t mCurrentRawVScroll;
     int32_t mCurrentRawHScroll;
 
-    // Id bits used to differentiate fingers, stylus and mouse tools.
-    BitSet32 mCurrentFingerIdBits; // finger or unknown
-    BitSet32 mLastFingerIdBits;
-    BitSet32 mCurrentStylusIdBits; // stylus or eraser
-    BitSet32 mLastStylusIdBits;
-    BitSet32 mCurrentMouseIdBits; // mouse or lens
-    BitSet32 mLastMouseIdBits;
+    // Id sets used to differentiate fingers, stylus and mouse tools.
+    IntSet mCurrentFingerIds; // finger or unknown
+    IntSet mLastFingerIds;
+    IntSet mCurrentStylusIds; // stylus or eraser
+    IntSet mLastStylusIds;
+    IntSet mCurrentMouseIds; // mouse or lens
+    IntSet mLastMouseIds;
 
     // True if we sent a HOVER_ENTER event.
     bool mSentHoverEnter;
@@ -1266,6 +1287,7 @@
     virtual bool hasStylus() const = 0;
 
     virtual void syncTouch(nsecs_t when, bool* outHavePointerIds) = 0;
+    int32_t fetchNewPointerId();
 
 private:
     // The surface orientation and width and height set by configureSurface().
@@ -1445,14 +1467,14 @@
 
         // Pointer coords and ids for the current and previous pointer gesture.
         Mode currentGestureMode;
-        BitSet32 currentGestureIdBits;
-        uint32_t currentGestureIdToIndex[MAX_POINTER_ID + 1];
+        IntSet currentGestureIds;
+        std::unordered_map<int32_t, uint32_t> currentGestureIdToIndex;
         PointerProperties currentGestureProperties[MAX_POINTERS];
         PointerCoords currentGestureCoords[MAX_POINTERS];
 
         Mode lastGestureMode;
-        BitSet32 lastGestureIdBits;
-        uint32_t lastGestureIdToIndex[MAX_POINTER_ID + 1];
+        IntSet lastGestureIds;
+        std::unordered_map<int32_t, uint32_t> lastGestureIdToIndex;
         PointerProperties lastGestureProperties[MAX_POINTERS];
         PointerCoords lastGestureCoords[MAX_POINTERS];
 
@@ -1479,14 +1501,14 @@
 
         // Distance that each pointer has traveled which has not yet been
         // subsumed into the reference gesture position.
-        BitSet32 referenceIdBits;
+        IntSet referenceIds;
         struct Delta {
             float dx, dy;
         };
-        Delta referenceDeltas[MAX_POINTER_ID + 1];
+        std::unordered_map<int32_t, Delta> referenceDeltas;
 
         // Describes how touch ids are mapped to gesture ids for freeform gestures.
-        uint32_t freeformTouchToGestureIdMap[MAX_POINTER_ID + 1];
+        std::unordered_map<int32_t, int32_t> freeformTouchToGestureIdMap;
 
         // A velocity tracker for determining whether to switch active pointers during drags.
         VelocityTracker velocityTracker;
@@ -1496,9 +1518,9 @@
             activeTouchId = -1;
             activeGestureId = -1;
             currentGestureMode = NEUTRAL;
-            currentGestureIdBits.clear();
+            currentGestureIds.clear();
             lastGestureMode = NEUTRAL;
-            lastGestureIdBits.clear();
+            lastGestureIds.clear();
             downTime = 0;
             velocityTracker.clear();
             resetTap();
@@ -1584,20 +1606,26 @@
             int32_t action, int32_t flags, int32_t metaState, int32_t buttonState,
             int32_t edgeFlags,
             const PointerProperties* properties, const PointerCoords* coords,
-            const uint32_t* idToIndex, BitSet32 idBits,
+            uint32_t inPointerCount,
+            int32_t changedId, float xPrecision, float yPrecision, nsecs_t downTime);
+    void dispatchMotion(nsecs_t when, uint32_t policyFlags, uint32_t source,
+            int32_t action, int32_t flags, int32_t metaState, int32_t buttonState,
+            int32_t edgeFlags,
+            const PointerProperties* properties, const PointerCoords* coords,
+            uint32_t inPointerCount, const IntSet &idsToDispatch,
             int32_t changedId, float xPrecision, float yPrecision, nsecs_t downTime);
 
-    // Updates pointer coords and properties for pointers with specified ids that have moved.
+    // Updates pointer coords and properties for pointers that have moved.
     // Returns true if any of them changed.
-    bool updateMovedPointers(const PointerProperties* inProperties,
-            const PointerCoords* inCoords, const uint32_t* inIdToIndex,
-            PointerProperties* outProperties, PointerCoords* outCoords,
-            const uint32_t* outIdToIndex, BitSet32 idBits) const;
+    bool updateMovedPointers(const PointerProperties* inProperties, const PointerCoords* inCoords,
+            uint32_t inPointerCount,  PointerProperties* outProperties, PointerCoords* outCoords,
+            uint32_t outPointerCount, const IntSet &commonTouchingIds) const;
 
     bool isPointInsideSurface(int32_t x, int32_t y);
     const VirtualKey* findVirtualKeyHit(int32_t x, int32_t y);
 
     void assignPointerIds();
+    int32_t mNextNewPointerId;
 };
 
 
@@ -1635,9 +1663,9 @@
 private:
     MultiTouchMotionAccumulator mMultiTouchMotionAccumulator;
 
-    // Specifies the pointer id bits that are in use, and their associated tracking id.
-    BitSet32 mPointerIdBits;
-    int32_t mPointerTrackingIdMap[MAX_POINTER_ID + 1];
+    // Specifies the pointer ids that are in use, and their associated tracking id.
+    IntSet mPointerIds;
+    std::unordered_map<int32_t, int32_t> mPointerTrackingIdMap;
 };
 
 

=== modified file '3rd_party/android-input/android/frameworks/base/services/input/InputTransport.cpp'
--- 3rd_party/android-input/android/frameworks/base/services/input/InputTransport.cpp	2013-05-31 16:06:07 +0000
+++ 3rd_party/android-input/android/frameworks/base/services/input/InputTransport.cpp	2013-11-25 03:07:43 +0000
@@ -593,7 +593,7 @@
             if (eventTime < touchState.lastResample.eventTime) {
                 rewriteMessage(touchState, msg);
             } else {
-                touchState.lastResample.idBits.clear();
+                touchState.lastResample.ids.clear();
             }
         }
         break;
@@ -603,7 +603,7 @@
         ssize_t index = findTouchState(deviceId, source);
         if (index >= 0) {
             TouchState& touchState = mTouchStates.editItemAt(index);
-            touchState.lastResample.idBits.clearBit(msg->body.motion.getActionId());
+            touchState.lastResample.ids.remove(msg->body.motion.getActionId());
             rewriteMessage(touchState, msg);
         }
         break;
@@ -614,7 +614,7 @@
         if (index >= 0) {
             TouchState& touchState = mTouchStates.editItemAt(index);
             rewriteMessage(touchState, msg);
-            touchState.lastResample.idBits.clearBit(msg->body.motion.getActionId());
+            touchState.lastResample.ids.remove(msg->body.motion.getActionId());
         }
         break;
     }
@@ -644,7 +644,7 @@
 void InputConsumer::rewriteMessage(const TouchState& state, InputMessage* msg) {
     for (size_t i = 0; i < msg->body.motion.pointerCount; i++) {
         uint32_t id = msg->body.motion.pointers[i].properties.id;
-        if (state.lastResample.idBits.hasBit(id)) {
+        if (state.lastResample.ids.contains(id)) {
             PointerCoords& msgCoords = msg->body.motion.pointers[i].coords;
             const PointerCoords& resampleCoords = state.lastResample.getPointerById(id);
 #if DEBUG_RESAMPLING
@@ -689,7 +689,7 @@
     size_t pointerCount = event->getPointerCount();
     for (size_t i = 0; i < pointerCount; i++) {
         uint32_t id = event->getPointerId(i);
-        if (!current->idBits.hasBit(id)) {
+        if (!current->ids.contains(id)) {
 #if DEBUG_RESAMPLING
             ALOGD("Not resampled, missing id %d", id);
 #endif
@@ -744,14 +744,14 @@
 
     // Resample touch coordinates.
     touchState.lastResample.eventTime = sampleTime;
-    touchState.lastResample.idBits.clear();
+    touchState.lastResample.ids.clear();
     for (size_t i = 0; i < pointerCount; i++) {
         uint32_t id = event->getPointerId(i);
         touchState.lastResample.idToIndex[id] = i;
-        touchState.lastResample.idBits.markBit(id);
+        touchState.lastResample.ids.insert(id);
         PointerCoords& resampledCoords = touchState.lastResample.pointers[i];
         const PointerCoords& currentCoords = current->getPointerById(id);
-        if (other->idBits.hasBit(id)
+        if (other->ids.contains(id)
                 && shouldResampleTool(event->getToolType(i))) {
             const PointerCoords& otherCoords = other->getPointerById(id);
             resampledCoords.copyFrom(currentCoords);

=== added file '3rd_party/android-input/android/frameworks/base/services/input/IntSet.cpp'
--- 3rd_party/android-input/android/frameworks/base/services/input/IntSet.cpp	1970-01-01 00:00:00 +0000
+++ 3rd_party/android-input/android/frameworks/base/services/input/IntSet.cpp	2013-11-25 03:07:43 +0000
@@ -0,0 +1,123 @@
+/*
+ * Copyright © 2013 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License version 3,
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Author: Daniel d'Andrada <[e-mail]>
+ */
+
+#include <androidfw/IntSet.h>
+
+#ifdef ANDROID_INPUT_INTSET_TEST
+using namespace test::android;
+#else
+using namespace android;
+#endif
+
+IntSet::IntSet() {
+#ifdef ANDROID_INPUT_INTSET_TEST
+        ++constructionCount;
+#endif
+}
+
+IntSet::IntSet(std::initializer_list<int32_t> list)
+    : stdSet(list) {
+#ifdef ANDROID_INPUT_INTSET_TEST
+    ++constructionCount;
+#endif
+}
+
+IntSet::~IntSet() {
+#ifdef ANDROID_INPUT_INTSET_TEST
+    ++destructionCount;
+#endif
+}
+
+IntSet IntSet::operator -(const IntSet &other) const {
+    IntSet result;
+
+    std::set_difference(stdSet.cbegin(), stdSet.cend(),
+            other.stdSet.cbegin(), other.stdSet.cend(),
+            std::inserter(result.stdSet, result.stdSet.begin()));
+
+    return result;
+}
+
+IntSet IntSet::operator &(const IntSet &other) const {
+    IntSet result;
+
+    std::set_intersection(stdSet.cbegin(), stdSet.cend(),
+            other.stdSet.cbegin(), other.stdSet.cend(),
+            std::inserter(result.stdSet, result.stdSet.begin()));
+
+    return result;
+}
+
+bool IntSet::operator ==(const IntSet &other) const {
+    return stdSet == other.stdSet;
+}
+
+void IntSet::remove(const IntSet &values) {
+    remove(stdSet.begin(), values.stdSet.begin(), values.stdSet.end());
+}
+
+bool IntSet::contains(int32_t value) const {
+    return stdSet.find(value) != stdSet.end();
+}
+
+size_t IntSet::indexOf(int32_t value) const {
+    auto it = stdSet.begin();
+    size_t index = 0;
+    while (it != stdSet.end() && *it != value) {
+        it++;
+        ++index;
+    }
+    assert(it != stdSet.end());
+    return index;
+}
+
+std::string IntSet::toString() const {
+    std::ostringstream stream;
+
+    bool isFirst = true;
+    forEach([&](int32_t value) {
+        if (isFirst) {
+            isFirst = false;
+        } else {
+            stream << ", ";
+        }
+        stream << value;
+    });
+
+    return stream.str();
+}
+
+void IntSet::remove(std::set<int32_t>::iterator selfIterator,
+                    std::set<int32_t>::const_iterator otherIterator,
+                    std::set<int32_t>::const_iterator otherEnd) {
+
+    if (selfIterator == stdSet.end() || otherIterator == otherEnd)
+        return;
+
+    if (*selfIterator < *otherIterator) {
+        selfIterator++;
+        remove(selfIterator, otherIterator, otherEnd);
+    } else if (*selfIterator == *otherIterator) {
+        selfIterator = stdSet.erase(selfIterator);
+        otherIterator++;
+        remove(selfIterator, otherIterator, otherEnd);
+    } else /* *selfIterator > *otherIterator */ {
+        otherIterator++;
+        remove(selfIterator, otherIterator, otherEnd);
+    }
+}

=== modified file '3rd_party/android-input/android/frameworks/base/services/input/PointerController.cpp'
--- 3rd_party/android-input/android/frameworks/base/services/input/PointerController.cpp	2012-11-06 18:05:11 +0000
+++ 3rd_party/android-input/android/frameworks/base/services/input/PointerController.cpp	2013-11-25 03:07:43 +0000
@@ -167,15 +167,12 @@
     }
 }
 
-void PointerController::setSpots(const PointerCoords* spotCoords,
-        const uint32_t* spotIdToIndex, BitSet32 spotIdBits) {
+void PointerController::setSpots(const PointerCoords* spotCoords, uint32_t spotCount) {
 #if DEBUG_POINTER_UPDATES
-    ALOGD("setSpots: idBits=%08x", spotIdBits.value);
-    for (BitSet32 idBits(spotIdBits); !idBits.isEmpty(); ) {
-        uint32_t id = idBits.firstMarkedBit();
-        idBits.clearBit(id);
-        const PointerCoords& c = spotCoords[spotIdToIndex[id]];
-        ALOGD(" spot %d: position=(%0.3f, %0.3f), pressure=%0.3f", id,
+    ALOGD("setSpots: spotCount=%d", spotCount);
+    for (size_t i = 0; i < spotCount; ++i) {
+        const PointerCoords& c = spotCoords[i];
+        ALOGD(" spot %d: position=(%0.3f, %0.3f), pressure=%0.3f", i,
                 c.getAxisValue(AMOTION_EVENT_AXIS_X),
                 c.getAxisValue(AMOTION_EVENT_AXIS_Y),
                 c.getAxisValue(AMOTION_EVENT_AXIS_PRESSURE));

=== modified file '3rd_party/android-input/android/frameworks/base/services/input/PointerController.h'
--- 3rd_party/android-input/android/frameworks/base/services/input/PointerController.h	2013-05-03 16:38:07 +0000
+++ 3rd_party/android-input/android/frameworks/base/services/input/PointerController.h	2013-11-25 03:07:43 +0000
@@ -18,7 +18,6 @@
 #define _UI_POINTER_CONTROLLER_H
 
 #include <androidfw/Input.h>
-#include <std/BitSet.h>
 #include <std/Mutex.h>
 #include <std/RefBase.h>
 #include <std/String8.h>
@@ -104,8 +103,7 @@
      * For spotCoords, pressure != 0 indicates that the spot's location is being
      * pressed (not hovering).
      */
-    virtual void setSpots(const PointerCoords* spotCoords, const uint32_t* spotIdToIndex,
-            BitSet32 spotIdBits) = 0;
+    virtual void setSpots(const PointerCoords* spotCoords, uint32_t spotCount) = 0;
 
     /* Removes all spots. */
     virtual void clearSpots() = 0;
@@ -139,8 +137,7 @@
     virtual void unfade(Transition transition);
 
     virtual void setPresentation(Presentation presentation);
-    virtual void setSpots(const PointerCoords* spotCoords,
-            const uint32_t* spotIdToIndex, BitSet32 spotIdBits);
+    virtual void setSpots(const PointerCoords* spotCoords, uint32_t spotCount);
     virtual void clearSpots();
 
     void setDisplaySize(int32_t width, int32_t height);

=== modified file '3rd_party/android-input/android/frameworks/base/services/input/VelocityControl.cpp'
--- 3rd_party/android-input/android/frameworks/base/services/input/VelocityControl.cpp	2013-05-03 16:38:07 +0000
+++ 3rd_party/android-input/android/frameworks/base/services/input/VelocityControl.cpp	2013-11-25 03:07:43 +0000
@@ -24,7 +24,6 @@
 #include <limits.h>
 
 #include <androidfw/VelocityControl.h>
-#include <std/BitSet.h>
 #include <std/Timers.h>
 
 namespace android {
@@ -35,6 +34,7 @@
 
 VelocityControl::VelocityControl() {
     reset();
+    mIds.insert(1);
 }
 
 void VelocityControl::setParameters(const VelocityControlParameters& parameters) {
@@ -66,7 +66,7 @@
         if (deltaY) {
             mRawPosition.y += *deltaY;
         }
-        mVelocityTracker.addMovement(eventTime, BitSet32(BitSet32::valueForBit(0)), &mRawPosition);
+        mVelocityTracker.addMovement(eventTime, mIds, &mRawPosition);
 
         float vx, vy;
         float scale = mParameters.scale;

=== modified file '3rd_party/android-input/android/frameworks/base/services/input/VelocityTracker.cpp'
--- 3rd_party/android-input/android/frameworks/base/services/input/VelocityTracker.cpp	2013-05-03 16:38:07 +0000
+++ 3rd_party/android-input/android/frameworks/base/services/input/VelocityTracker.cpp	2013-11-25 03:07:43 +0000
@@ -27,7 +27,7 @@
 #include <limits.h>
 
 #include <androidfw/VelocityTracker.h>
-#include <std/BitSet.h>
+#include <androidfw/IntSet.h>
 #include <std/String8.h>
 #include <std/Timers.h>
 #include <std/Log.h>
@@ -109,7 +109,7 @@
 const char* VelocityTracker::DEFAULT_STRATEGY = "lsq2";
 
 VelocityTracker::VelocityTracker(const char* strategy) :
-        mLastEventTime(0), mCurrentPointerIdBits(0), mActivePointerId(-1) {
+        mLastEventTime(0), mActivePointerId(-1) {
     char value[PROPERTY_VALUE_MAX];
 
     // Allow the default strategy to be overridden using a system property for debugging.
@@ -202,29 +202,24 @@
 }
 
 void VelocityTracker::clear() {
-    mCurrentPointerIdBits.clear();
+    mCurrentPointerIds.clear();
     mActivePointerId = -1;
 
     mStrategy->clear();
 }
 
-void VelocityTracker::clearPointers(BitSet32 idBits) {
-    BitSet32 remainingIdBits(mCurrentPointerIdBits.value & ~idBits.value);
-    mCurrentPointerIdBits = remainingIdBits;
+void VelocityTracker::clearPointers(const IntSet &ids) {
+    mCurrentPointerIds.remove(ids);
 
-    if (mActivePointerId >= 0 && idBits.hasBit(mActivePointerId)) {
-        mActivePointerId = !remainingIdBits.isEmpty() ? remainingIdBits.firstMarkedBit() : -1;
+    if (mActivePointerId >= 0 && ids.contains(mActivePointerId)) {
+        mActivePointerId = !mCurrentPointerIds.isEmpty() ? mCurrentPointerIds.first() : -1;
     }
 
-    mStrategy->clearPointers(idBits);
+    mStrategy->clearPointers(ids);
 }
 
-void VelocityTracker::addMovement(nsecs_t eventTime, BitSet32 idBits, const Position* positions) {
-    while (idBits.count() > MAX_POINTERS) {
-        idBits.clearLastMarkedBit();
-    }
-
-    if ((mCurrentPointerIdBits.value & idBits.value)
+void VelocityTracker::addMovement(nsecs_t eventTime, const IntSet &ids, const Position* positions) {
+    if (!(mCurrentPointerIds & ids).isEmpty()
             && eventTime >= mLastEventTime + ASSUME_POINTER_STOPPED_TIME) {
 #if DEBUG_VELOCITY
         ALOGD("VelocityTracker: stopped for %0.3f ms, clearing state.",
@@ -236,20 +231,18 @@
     }
     mLastEventTime = eventTime;
 
-    mCurrentPointerIdBits = idBits;
-    if (mActivePointerId < 0 || !idBits.hasBit(mActivePointerId)) {
-        mActivePointerId = idBits.isEmpty() ? -1 : idBits.firstMarkedBit();
+    mCurrentPointerIds = ids;
+    if (mActivePointerId < 0 || !ids.contains(mActivePointerId)) {
+        mActivePointerId = ids.isEmpty() ? -1 : ids.first();
     }
 
-    mStrategy->addMovement(eventTime, idBits, positions);
+    mStrategy->addMovement(eventTime, ids, positions);
 
 #if DEBUG_VELOCITY
-    ALOGD("VelocityTracker: addMovement eventTime=%lld, idBits=0x%08x, activePointerId=%d",
-            eventTime, idBits.value, mActivePointerId);
-    for (BitSet32 iterBits(idBits); !iterBits.isEmpty(); ) {
-        uint32_t id = iterBits.firstMarkedBit();
-        uint32_t index = idBits.getIndexOfBit(id);
-        iterBits.clearBit(id);
+    ALOGD("VelocityTracker: addMovement eventTime=%lld, ids.cont()=%d, activePointerId=%d",
+            eventTime, ids.count(), mActivePointerId);
+    size_t index = 0;
+    ids.forEach([&](int32_t id) {
         Estimator estimator;
         getEstimator(id, &estimator);
         ALOGD("  %d: position (%0.3f, %0.3f), "
@@ -259,6 +252,7 @@
                 vectorToString(estimator.xCoeff, estimator.degree + 1).string(),
                 vectorToString(estimator.yCoeff, estimator.degree + 1).string(),
                 estimator.confidence);
+        ++index;
     }
 #endif
 }
@@ -276,9 +270,9 @@
         // Start a new movement trace for a pointer that just went down.
         // We do this on down instead of on up because the client may want to query the
         // final velocity for a pointer that just went up.
-        BitSet32 downIdBits;
-        downIdBits.markBit(event->getPointerId(event->getActionIndex()));
-        clearPointers(downIdBits);
+        IntSet downIds;
+        downIds.insert(event->getPointerId(event->getActionIndex()));
+        clearPointers(downIds);
         break;
     }
     case AMOTION_EVENT_ACTION_MOVE:
@@ -301,14 +295,14 @@
         pointerCount = MAX_POINTERS;
     }
 
-    BitSet32 idBits;
+    IntSet ids;
     for (size_t i = 0; i < pointerCount; i++) {
-        idBits.markBit(event->getPointerId(i));
+        ids.insert(event->getPointerId(i));
     }
 
     uint32_t pointerIndex[MAX_POINTERS];
     for (size_t i = 0; i < pointerCount; i++) {
-        pointerIndex[i] = idBits.getIndexOfBit(event->getPointerId(i));
+        pointerIndex[i] = ids.indexOf(event->getPointerId(i));
     }
 
     nsecs_t eventTime;
@@ -322,7 +316,7 @@
             positions[index].x = event->getHistoricalX(i, h);
             positions[index].y = event->getHistoricalY(i, h);
         }
-        addMovement(eventTime, idBits, positions);
+        addMovement(eventTime, ids, positions);
     }
 
     eventTime = event->getEventTime();
@@ -331,7 +325,7 @@
         positions[index].x = event->getX(i);
         positions[index].y = event->getY(i);
     }
-    addMovement(eventTime, idBits, positions);
+    addMovement(eventTime, ids, positions);
 }
 
 bool VelocityTracker::getVelocity(uint32_t id, float* outVx, float* outVy) const {
@@ -367,15 +361,14 @@
 
 void LeastSquaresVelocityTrackerStrategy::clear() {
     mIndex = 0;
-    mMovements[0].idBits.clear();
-}
-
-void LeastSquaresVelocityTrackerStrategy::clearPointers(BitSet32 idBits) {
-    BitSet32 remainingIdBits(mMovements[mIndex].idBits.value & ~idBits.value);
-    mMovements[mIndex].idBits = remainingIdBits;
-}
-
-void LeastSquaresVelocityTrackerStrategy::addMovement(nsecs_t eventTime, BitSet32 idBits,
+    mMovements[0].ids.clear();
+}
+
+void LeastSquaresVelocityTrackerStrategy::clearPointers(const IntSet &ids) {
+    mMovements[mIndex].ids.remove(ids);
+}
+
+void LeastSquaresVelocityTrackerStrategy::addMovement(nsecs_t eventTime, const IntSet &ids,
         const VelocityTracker::Position* positions) {
     if (++mIndex == HISTORY_SIZE) {
         mIndex = 0;
@@ -383,9 +376,9 @@
 
     Movement& movement = mMovements[mIndex];
     movement.eventTime = eventTime;
-    movement.idBits = idBits;
-    uint32_t count = idBits.count();
-    for (uint32_t i = 0; i < count; i++) {
+    movement.ids = ids;
+    size_t count = ids.count();
+    for (size_t i = 0; i < count; i++) {
         movement.positions[i] = positions[i];
     }
 }
@@ -570,7 +563,7 @@
     const Movement& newestMovement = mMovements[mIndex];
     do {
         const Movement& movement = mMovements[index];
-        if (!movement.idBits.hasBit(id)) {
+        if (!movement.ids.contains(id)) {
             break;
         }
 
@@ -702,36 +695,44 @@
 }
 
 void IntegratingVelocityTrackerStrategy::clear() {
-    mPointerIdBits.clear();
-}
-
-void IntegratingVelocityTrackerStrategy::clearPointers(BitSet32 idBits) {
-    mPointerIdBits.value &= ~idBits.value;
-}
-
-void IntegratingVelocityTrackerStrategy::addMovement(nsecs_t eventTime, BitSet32 idBits,
+    mPointerIds.clear();
+}
+
+void IntegratingVelocityTrackerStrategy::clearPointers(const IntSet &ids) {
+    mPointerIds.remove(ids);
+}
+
+void IntegratingVelocityTrackerStrategy::addMovement(nsecs_t eventTime, const IntSet &ids,
         const VelocityTracker::Position* positions) {
-    uint32_t index = 0;
-    for (BitSet32 iterIdBits(idBits); !iterIdBits.isEmpty();) {
-        uint32_t id = iterIdBits.clearFirstMarkedBit();
-        State& state = mPointerState[id];
-        const VelocityTracker::Position& position = positions[index++];
-        if (mPointerIdBits.hasBit(id)) {
-            updateState(state, eventTime, position.x, position.y);
-        } else {
-            initState(state, eventTime, position.x, position.y);
-        }
+
+    {
+        auto pointerIdsIt = mPointerIds.begin();
+        uint32_t index = 0;
+
+        for_each(ids.begin(), ids.end(), [&](int32_t id) {
+            State& state = mPointerState[id];
+            const VelocityTracker::Position& position = positions[index++];
+
+            while (*pointerIdsIt < id && pointerIdsIt != mPointerIds.end())
+                pointerIdsIt++;
+
+            if (pointerIdsIt != mPointerIds.end() && *pointerIdsIt == id) {
+                updateState(state, eventTime, position.x, position.y);
+            } else {
+                initState(state, eventTime, position.x, position.y);
+            }
+        });
     }
 
-    mPointerIdBits = idBits;
+    mPointerIds = ids;
 }
 
 bool IntegratingVelocityTrackerStrategy::getEstimator(uint32_t id,
         VelocityTracker::Estimator* outEstimator) const {
     outEstimator->clear();
 
-    if (mPointerIdBits.hasBit(id)) {
-        const State& state = mPointerState[id];
+    if (mPointerIds.contains(id)) {
+        const State& state = mPointerState.at(id);
         populateEstimator(state, outEstimator);
         return true;
     }
@@ -823,15 +824,14 @@
 
 void LegacyVelocityTrackerStrategy::clear() {
     mIndex = 0;
-    mMovements[0].idBits.clear();
-}
-
-void LegacyVelocityTrackerStrategy::clearPointers(BitSet32 idBits) {
-    BitSet32 remainingIdBits(mMovements[mIndex].idBits.value & ~idBits.value);
-    mMovements[mIndex].idBits = remainingIdBits;
-}
-
-void LegacyVelocityTrackerStrategy::addMovement(nsecs_t eventTime, BitSet32 idBits,
+    mMovements[0].ids.clear();
+}
+
+void LegacyVelocityTrackerStrategy::clearPointers(const IntSet &ids) {
+    mMovements[mIndex].ids.remove(ids);
+}
+
+void LegacyVelocityTrackerStrategy::addMovement(nsecs_t eventTime, const IntSet &ids,
         const VelocityTracker::Position* positions) {
     if (++mIndex == HISTORY_SIZE) {
         mIndex = 0;
@@ -839,11 +839,8 @@
 
     Movement& movement = mMovements[mIndex];
     movement.eventTime = eventTime;
-    movement.idBits = idBits;
-    uint32_t count = idBits.count();
-    for (uint32_t i = 0; i < count; i++) {
-        movement.positions[i] = positions[i];
-    }
+    movement.ids = ids;
+    memcpy(movement.positions, positions, sizeof(VelocityTracker::Position) * ids.count());
 }
 
 bool LegacyVelocityTrackerStrategy::getEstimator(uint32_t id,
@@ -851,7 +848,7 @@
     outEstimator->clear();
 
     const Movement& newestMovement = mMovements[mIndex];
-    if (!newestMovement.idBits.hasBit(id)) {
+    if (!newestMovement.ids.contains(id)) {
         return false; // no data
     }
 
@@ -862,7 +859,7 @@
     do {
         uint32_t nextOldestIndex = (oldestIndex == 0 ? HISTORY_SIZE : oldestIndex) - 1;
         const Movement& nextOldestMovement = mMovements[nextOldestIndex];
-        if (!nextOldestMovement.idBits.hasBit(id)
+        if (!nextOldestMovement.ids.contains(id)
                 || nextOldestMovement.eventTime < minTime) {
             break;
         }

=== modified file 'CMakeLists.txt'
--- CMakeLists.txt	2013-11-06 03:17:35 +0000
+++ CMakeLists.txt	2013-11-25 03:07:43 +0000
@@ -28,7 +28,7 @@
 
 set(MIR_VERSION_MAJOR 0)
 set(MIR_VERSION_MINOR 1)
-set(MIR_VERSION_PATCH 1)
+set(MIR_VERSION_PATCH 2)
 
 set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} ${CMAKE_CURRENT_SOURCE_DIR}/cmake)
 

=== modified file 'debian/changelog'
--- debian/changelog	2013-11-20 07:36:15 +0000
+++ debian/changelog	2013-11-25 03:07:43 +0000
@@ -1,3 +1,96 @@
+mir (0.1.2-0ubuntu1) UNRELEASED; urgency=low
+
+  * New upstream release 0.1.2
+    - graphics: android: improve interface for mga::DisplayDevice so its
+      just concerned with rendering and posting.
+    - surfaces: rename "surfaces" component to "scene".
+    - surfaces, shell: Migrate Session data model from shell to surfaces.
+    - graphics: change fill_ipc_package() to use real pointers.
+    - mir_client_library.h: Fix typo "do and locking" should be "do any
+      locking".
+    - API enumerations cleanup: Remove slightly misleading *_enum_max_
+      values, and replace them with more accurate plural forms.
+    - test_android_communication_package: Do not expect opened fd to be >0,
+      we may have closed stdin making this a valid value (LP: #1247718).
+    - Update docs about running Mir on the desktop to mention new package
+      ubuntu-desktop-mir.
+    - offscreen: Add a display that renders its output to offscreen buffers
+    - graphics: android: fix regression for hwc1.0 devices introduced in r1228
+      (LP: #1252433).
+    - OffscreenPlatform provides the services that the offscreen display
+      needs from the Platform.
+    - graphics: android: consolidate the GLContexts classes in use.
+    - Fix uninitialized variable causing random drm_auth_magic test
+      failures. (LP: #1252144).
+    - Add a fullyish functional Udev wrapper. This currently sits in
+      graphics/gbm, but will be moved to the top-level when input device
+      detection migrates.
+    - Add resizing support to example code; demo-shell and clients.
+    - eglapp: Clarify messages about pixel formats (LP: #1168304).
+    - Adds support to the MirMotionEvent under pointer_coordinates called
+      tool_type. This will allow clients to tell what type of tool is
+      being used, from mouse/finger/etc. (LP: #1252498)
+    - client,frontend: Report the real available surface pixel formats to
+      clients. (LP: #1240833)
+    - graphics: android: 1) change hwc1.1 to make use of sync fences during
+      the compositor's gl renderloop. Note that we no longer wait for the
+      render to complete, we pass this responsibility to the driver and the
+      kernel. 2) support nexus 10. (LP: #1252173) (LP: #1203268)
+    - shell: don't publish SurfacesContainer - it can be private to shell.
+    - gbm: Don't mess up the VT mode on setup failure Only restore the
+      previous VT mode during shutdown if it was VT_AUTO.
+    - Fix a crash due to a failed eglMakeCurrent() call when in nested mode.
+    - shell: unity-mir uses shell::FocusSetter - make the header public again
+    - Add resize support to client surfaces (mir::client::MirSurface).
+    - graphics: android: support 'old aka 2012' nexus 7 hwc (nvidia tegra3
+      SoC) better. (LP: #1231917)
+    - Add resize support to *ClientBuffer classes. Now always get dimensions
+      from the latest buffer package.
+    - android: support driver hooks for the Mali T604 (present in nexus 10)
+    - Add width and height to the protocol Buffer messages, in preparation
+      for resizable surfaces.
+    - surfaces, shell, logging, tests: don't publish headers
+      that can be private to surfaces. surfaces/basic_surface.h,
+      surfaces/surface_controller.h and shell/surface_builder.h
+    - examples: Restore GL framebuffer binding when destroying the render
+      target
+    - examples, surfaces, shell: remove render_surfaces dependency on
+      BasicSurface
+    - geometry: remove implementation of streaming operators from headers
+      (LP: #1247820)
+    - Eliminate the registration order focus sequence, folding it's
+      functionality in to the session container.
+    - Ensure the session mediator releases acquired buffer resources before
+      attempting to acquire a new buffer on behalf of the client. This fixes
+      performance regression (LP: #1249210).
+    - Some cleanups to test_client_input.cpp.
+    - Factor out a bunch of "ClientConfigCommon".
+    - Small cleanup to session container test to increase encapsulation.
+    - shell, surfaces: Another step in "fixing" the surfaces hierarchies -
+      only publish interfaces and putting the data model into surfaces.
+    - graphics: android: HWC1.1 use EGL to get further information about
+      the framebuffer pixel format.
+    - Fix FTBS using use_debflags=ON (building for android-armhf).
+      (LP: #1248014)
+    - Add a client input receiver report.
+    - doc: doxygen 1.8.4 complains about an obsolete config so ran "doxygen
+      u Doxyfile.in".
+    - Implement resize() for the server-side Surface classes.
+    - android: clean up mga::DisplayBuffer and mga::DisplayBufferFactory
+    - Add resize() support to BufferStream, in preparation for resizable
+      surfaces.
+    - Merge metadata changes from the newly reconstructed lp:mir
+    - tests: Deduplicate mg::GraphicBufferAllocator stubs.
+    - examples: Remove spurious use of mir/shell/surface.h.
+    - frontend: remove ClientTrackingSurface from the Surface class
+      hierarchy
+    - Bumping ABI on server to libmirserver11.
+    - Don't mention "Renderable". That interface hasn't existed for quite
+      some time now.
+    - android-input: Assign more unique touch ids
+
+ -- Kevin Gunn <[e-mail]>  Fri, 22 Nov 2013 12:34:52 -0600
+
 mir (0.1.1+14.04.20131120-0ubuntu1) trusty; urgency=low
 
   [ Daniel van Vugt ]

=== modified file 'debian/control'
--- debian/control	2013-11-06 03:17:35 +0000
+++ debian/control	2013-11-25 03:07:43 +0000
@@ -69,7 +69,7 @@
  .
  Contains the protocol's definition files.
 
-Package: libmirserver10
+Package: libmirserver11
 Section: libs
 Architecture: i386 amd64 armhf arm64
 Multi-Arch: same
@@ -115,7 +115,7 @@
 Architecture: i386 amd64 armhf arm64
 Multi-Arch: same
 Pre-Depends: ${misc:Pre-Depends}
-Depends: libmirserver10 (= ${binary:Version}),
+Depends: libmirserver11 (= ${binary:Version}),
          libmirprotobuf-dev (= ${binary:Version}),
          mircommon-dev (= ${binary:Version}),
          libglm-dev,

=== renamed file 'debian/libmirserver10.install' => 'debian/libmirserver11.install'
--- debian/libmirserver10.install	2013-11-06 03:17:35 +0000
+++ debian/libmirserver11.install	2013-11-25 03:07:43 +0000
@@ -1,1 +1,1 @@
-usr/lib/*/libmirserver.so.10
+usr/lib/*/libmirserver.so.11

=== modified file 'debian/rules' (properties changed: -x to +x)
=== modified file 'doc/Doxyfile.in'
--- doc/Doxyfile.in	2013-07-02 11:27:33 +0000
+++ doc/Doxyfile.in	2013-11-25 03:07:43 +0000
@@ -1,14 +1,16 @@
-# Doxyfile 1.8.1.2
+# Doxyfile 1.8.4
 
 # This file describes the settings to be used by the documentation system
-# doxygen (www.doxygen.org) for a project
+# doxygen (www.doxygen.org) for a project.
 #
-# All text after a hash (#) is considered a comment and will be ignored
+# All text after a double hash (##) is considered a comment and is placed
+# in front of the TAG it is preceding .
+# All text after a hash (#) is considered a comment and will be ignored.
 # The format is:
 #       TAG = value [value, ...]
 # For lists items can also be appended using:
 #       TAG += value [value, ...]
-# Values that contain spaces should be placed between quotes (" ")
+# Values that contain spaces should be placed between quotes (" ").
 
 #---------------------------------------------------------------------------
 # Project related configuration options
@@ -70,9 +72,9 @@
 # Afrikaans, Arabic, Brazilian, Catalan, Chinese, Chinese-Traditional,
 # Croatian, Czech, Danish, Dutch, Esperanto, Farsi, Finnish, French, German,
 # Greek, Hungarian, Italian, Japanese, Japanese-en (Japanese with English
-# messages), Korean, Korean-en, Lithuanian, Norwegian, Macedonian, Persian,
-# Polish, Portuguese, Romanian, Russian, Serbian, Serbian-Cyrillic, Slovak,
-# Slovene, Spanish, Swedish, Ukrainian, and Vietnamese.
+# messages), Korean, Korean-en, Latvian, Lithuanian, Norwegian, Macedonian,
+# Persian, Polish, Portuguese, Romanian, Russian, Serbian, Serbian-Cyrillic,
+# Slovak, Slovene, Spanish, Swedish, Ukrainian, and Vietnamese.
 
 OUTPUT_LANGUAGE        = English
 
@@ -136,7 +138,9 @@
 # only done if one of the specified strings matches the left-hand part of
 # the path. The tag can be used to show relative paths in the file list.
 # If left blank the directory from which doxygen is run is used as the
-# path to strip.
+# path to strip. Note that you specify absolute paths here, but also
+# relative paths, which will be relative from the directory where doxygen is
+# started.
 
 STRIP_FROM_PATH        = @CMAKE_CURRENT_SOURCE_DIR@
 
@@ -239,14 +243,15 @@
 OPTIMIZE_OUTPUT_VHDL   = NO
 
 # Doxygen selects the parser to use depending on the extension of the files it
-# parses. With this tag you can assign which parser to use for a given extension.
-# Doxygen has a built-in mapping, but you can override or extend it using this
-# tag. The format is ext=language, where ext is a file extension, and language
-# is one of the parsers supported by doxygen: IDL, Java, Javascript, CSharp, C,
-# C++, D, PHP, Objective-C, Python, Fortran, VHDL, C, C++. For instance to make
-# doxygen treat .inc files as Fortran files (default is PHP), and .f files as C
-# (default is Fortran), use: inc=Fortran f=C. Note that for custom extensions
-# you also need to set FILE_PATTERNS otherwise the files are not read by doxygen.
+# parses. With this tag you can assign which parser to use for a given
+# extension. Doxygen has a built-in mapping, but you can override or extend it
+# using this tag. The format is ext=language, where ext is a file extension,
+# and language is one of the parsers supported by doxygen: IDL, Java,
+# Javascript, CSharp, C, C++, D, PHP, Objective-C, Python, Fortran, VHDL, C,
+# C++. For instance to make doxygen treat .inc files as Fortran files (default
+# is PHP), and .f files as C (default is Fortran), use: inc=Fortran f=C. Note
+# that for custom extensions you also need to set FILE_PATTERNS otherwise the
+# files are not read by doxygen.
 
 EXTENSION_MAPPING      =
 
@@ -259,6 +264,13 @@
 
 MARKDOWN_SUPPORT       = YES
 
+# When enabled doxygen tries to link words that correspond to documented
+# classes, or namespaces to their corresponding documentation. Such a link can
+# be prevented in individual cases by by putting a % sign in front of the word
+# or globally by setting AUTOLINK_SUPPORT to NO.
+
+AUTOLINK_SUPPORT       = YES
+
 # If you use STL classes (i.e. std::string, std::vector, etc.) but do not want
 # to include (a tag file for) the STL sources as input, then you should
 # set this tag to YES in order to let doxygen match functions declarations and
@@ -279,10 +291,10 @@
 
 SIP_SUPPORT            = NO
 
-# For Microsoft's IDL there are propget and propput attributes to indicate getter
-# and setter methods for a property. Setting this option to YES (the default)
-# will make doxygen replace the get and set methods by a property in the
-# documentation. This will only work if the methods are indeed getting or
+# For Microsoft's IDL there are propget and propput attributes to indicate
+# getter and setter methods for a property. Setting this option to YES (the
+# default) will make doxygen replace the get and set methods by a property in
+# the documentation. This will only work if the methods are indeed getting or
 # setting a simple type. If this is not the case, or you want to show the
 # methods anyway, you should set this option to NO.
 
@@ -311,11 +323,11 @@
 INLINE_GROUPED_CLASSES = NO
 
 # When the INLINE_SIMPLE_STRUCTS tag is set to YES, structs, classes, and
-# unions with only public data fields will be shown inline in the documentation
-# of the scope in which they are defined (i.e. file, namespace, or group
-# documentation), provided this scope is documented. If set to NO (the default),
-# structs, classes, and unions are shown on a separate page (for HTML and Man
-# pages) or section (for LaTeX and RTF).
+# unions with only public data fields or simple typedef fields will be shown
+# inline in the documentation of the scope in which they are defined (i.e. file,
+# namespace, or group documentation), provided this scope is documented. If set
+# to NO (the default), structs, classes, and unions are shown on a separate
+# page (for HTML and Man pages) or section (for LaTeX and RTF).
 
 INLINE_SIMPLE_STRUCTS  = NO
 
@@ -329,30 +341,14 @@
 
 TYPEDEF_HIDES_STRUCT   = NO
 
-# The SYMBOL_CACHE_SIZE determines the size of the internal cache use to
-# determine which symbols to keep in memory and which to flush to disk.
-# When the cache is full, less often used symbols will be written to disk.
-# For small to medium size projects (<1000 input files) the default value is
-# probably good enough. For larger projects a too small cache size can cause
-# doxygen to be busy swapping symbols to and from disk most of the time
-# causing a significant performance penalty.
-# If the system has enough physical memory increasing the cache will improve the
-# performance by keeping more symbols in memory. Note that the value works on
-# a logarithmic scale so increasing the size by one will roughly double the
-# memory usage. The cache size is given by this formula:
-# 2^(16+SYMBOL_CACHE_SIZE). The valid range is 0..9, the default is 0,
-# corresponding to a cache size of 2^16 = 65536 symbols.
-
-SYMBOL_CACHE_SIZE      = 0
-
-# Similar to the SYMBOL_CACHE_SIZE the size of the symbol lookup cache can be
-# set using LOOKUP_CACHE_SIZE. This cache is used to resolve symbols given
-# their name and scope. Since this can be an expensive process and often the
-# same symbol appear multiple times in the code, doxygen keeps a cache of
-# pre-resolved symbols. If the cache is too small doxygen will become slower.
-# If the cache is too large, memory is wasted. The cache size is given by this
-# formula: 2^(16+LOOKUP_CACHE_SIZE). The valid range is 0..9, the default is 0,
-# corresponding to a cache size of 2^16 = 65536 symbols.
+# The size of the symbol lookup cache can be set using LOOKUP_CACHE_SIZE. This
+# cache is used to resolve symbols given their name and scope. Since this can
+# be an expensive process and often the same symbol appear multiple times in
+# the code, doxygen keeps a cache of pre-resolved symbols. If the cache is too
+# small doxygen will become slower. If the cache is too large, memory is wasted.
+# The cache size is given by this formula: 2^(16+LOOKUP_CACHE_SIZE). The valid
+# range is 0..9, the default is 0, corresponding to a cache size of 2^16 = 65536
+# symbols.
 
 LOOKUP_CACHE_SIZE      = 0
 
@@ -363,7 +359,7 @@
 # If the EXTRACT_ALL tag is set to YES doxygen will assume all entities in
 # documentation are documented, even if no documentation was available.
 # Private class members and static file members will be hidden unless
-# the EXTRACT_PRIVATE and EXTRACT_STATIC tags are set to YES
+# the EXTRACT_PRIVATE respectively EXTRACT_STATIC tags are set to YES
 
 EXTRACT_ALL            = YES
 
@@ -544,7 +540,8 @@
 GENERATE_DEPRECATEDLIST= YES
 
 # The ENABLED_SECTIONS tag can be used to enable conditional
-# documentation sections, marked by \if sectionname ... \endif.
+# documentation sections, marked by \if section-label ... \endif
+# and \cond section-label ... \endcond blocks.
 
 ENABLED_SECTIONS       =
 
@@ -571,7 +568,8 @@
 SHOW_FILES             = YES
 
 # Set the SHOW_NAMESPACES tag to NO to disable the generation of the
-# Namespaces page.  This will remove the Namespaces entry from the Quick Index
+# Namespaces page.
+# This will remove the Namespaces entry from the Quick Index
 # and from the Folder Tree View (if specified). The default is YES.
 
 SHOW_NAMESPACES        = YES
@@ -601,7 +599,8 @@
 # requires the bibtex tool to be installed. See also
 # http://en.wikipedia.org/wiki/BibTeX for more info. For LaTeX the style
 # of the bibliography can be controlled using LATEX_BIB_STYLE. To use this
-# feature you need bibtex and perl available in the search path.
+# feature you need bibtex and perl available in the search path. Do not use
+# file names with spaces, bibtex cannot handle them.
 
 CITE_BIB_FILES         =
 
@@ -757,7 +756,11 @@
 # wildcard * is used, a substring. Examples: ANamespace, AClass,
 # AClass::ANamespace, ANamespace::*Test
 
-EXCLUDE_SYMBOLS        = android google mfd mgg mp
+EXCLUDE_SYMBOLS        = android \
+                         google \
+                         mfd \
+                         mgg \
+                         mp
 
 # The EXAMPLE_PATH tag can be used to specify one or more files or
 # directories that contain example code fragments that are included (see
@@ -790,14 +793,19 @@
 # by executing (via popen()) the command <filter> <input-file>, where <filter>
 # is the value of the INPUT_FILTER tag, and <input-file> is the name of an
 # input file. Doxygen will then use the output that the filter program writes
-# to standard output.  If FILTER_PATTERNS is specified, this tag will be
-# ignored.
+# to standard output.
+# If FILTER_PATTERNS is specified, this tag will be ignored.
+# Note that the filter must not add or remove lines; it is applied before the
+# code is scanned, but not when the output code is generated. If lines are added
+# or removed, the anchors will not be placed correctly.
 
 INPUT_FILTER           =
 
 # The FILTER_PATTERNS tag can be used to specify filters on a per file pattern
-# basis.  Doxygen will compare the file name with each pattern and apply the
-# filter if there is a match.  The filters are a list of the form:
+# basis.
+# Doxygen will compare the file name with each pattern and apply the
+# filter if there is a match.
+# The filters are a list of the form:
 # pattern=filter (like *.cpp=my_cpp_filter). See INPUT_FILTER for further
 # info on how filters are used. If FILTER_PATTERNS is empty or if
 # non of the patterns match the file name, INPUT_FILTER is applied.
@@ -818,6 +826,13 @@
 
 FILTER_SOURCE_PATTERNS =
 
+# If the USE_MD_FILE_AS_MAINPAGE tag refers to the name of a markdown file that
+# is part of the input, its contents will be placed on the main page
+# (index.html). This can be useful if you have a project on for instance GitHub
+# and want reuse the introduction page also for the doxygen output.
+
+USE_MDFILE_AS_MAINPAGE =
+
 #---------------------------------------------------------------------------
 # configuration options related to source browsing
 #---------------------------------------------------------------------------
@@ -855,7 +870,8 @@
 # If the REFERENCES_LINK_SOURCE tag is set to YES (the default)
 # and SOURCE_BROWSER tag is set to YES, then the hyperlinks from
 # functions in REFERENCES_RELATION and REFERENCED_BY_RELATION lists will
-# link to the source code.  Otherwise they will link to the documentation.
+# link to the source code.
+# Otherwise they will link to the documentation.
 
 REFERENCES_LINK_SOURCE = YES
 
@@ -920,7 +936,7 @@
 # The HTML_HEADER tag can be used to specify a personal HTML header for
 # each generated HTML page. If it is left blank doxygen will generate a
 # standard header. Note that when using a custom header you are responsible
-# for the proper inclusion of any scripts and style sheets that doxygen
+#  for the proper inclusion of any scripts and style sheets that doxygen
 # needs, which is dependent on the configuration options used.
 # It is advised to generate a default header using "doxygen -w html
 # header.html footer.html stylesheet.css YourConfigFile" and then modify
@@ -938,18 +954,27 @@
 
 # The HTML_STYLESHEET tag can be used to specify a user-defined cascading
 # style sheet that is used by each HTML page. It can be used to
-# fine-tune the look of the HTML output. If the tag is left blank doxygen
-# will generate a default style sheet. Note that doxygen will try to copy
-# the style sheet file to the HTML output directory, so don't put your own
-# style sheet in the HTML output directory as well, or it will be erased!
+# fine-tune the look of the HTML output. If left blank doxygen will
+# generate a default style sheet. Note that it is recommended to use
+# HTML_EXTRA_STYLESHEET instead of this one, as it is more robust and this
+# tag will in the future become obsolete.
 
 HTML_STYLESHEET        =
+
+# The HTML_EXTRA_STYLESHEET tag can be used to specify an additional
+# user-defined cascading style sheet that is included after the standard
+# style sheets created by doxygen. Using this option one can overrule
+# certain style aspects. This is preferred over using HTML_STYLESHEET
+# since it does not replace the standard style sheet and is therefor more
+# robust against future updates. Doxygen will copy the style sheet file to
+# the output directory.
+
 HTML_EXTRA_STYLESHEET  = @CMAKE_BINARY_DIR@/doc/extra.css
 
 # The HTML_EXTRA_FILES tag can be used to specify one or more extra images or
 # other source files which should be copied to the HTML output directory. Note
 # that these files will be copied to the base HTML output directory. Use the
-# $relpath$ marker in the HTML_HEADER and/or HTML_FOOTER files to load these
+# $relpath^ marker in the HTML_HEADER and/or HTML_FOOTER files to load these
 # files. In the HTML_STYLESHEET file, use the file name only. Also note that
 # the files will be copied as-is; there are no commands or markers available.
 
@@ -1030,9 +1055,9 @@
 
 DOCSET_BUNDLE_ID       = org.doxygen.Project
 
-# When GENERATE_PUBLISHER_ID tag specifies a string that should uniquely identify
-# the documentation publisher. This should be a reverse domain-name style
-# string, e.g. com.mycompany.MyDocSet.documentation.
+# When GENERATE_PUBLISHER_ID tag specifies a string that should uniquely
+# identify the documentation publisher. This should be a reverse domain-name
+# style string, e.g. com.mycompany.MyDocSet.documentation.
 
 DOCSET_PUBLISHER_ID    = org.doxygen.Publisher
 
@@ -1138,7 +1163,7 @@
 QHG_LOCATION           =
 
 # If the GENERATE_ECLIPSEHELP tag is set to YES, additional index files
-# will be generated, which together with the HTML files, form an Eclipse help
+#  will be generated, which together with the HTML files, form an Eclipse help
 # plugin. To install this plugin and make it available under the help contents
 # menu in Eclipse, the contents of the directory containing the HTML and XML
 # files needs to be copied into the plugins directory of eclipse. The name of
@@ -1217,13 +1242,21 @@
 
 USE_MATHJAX            = NO
 
+# When MathJax is enabled you can set the default output format to be used for
+# the MathJax output. Supported types are HTML-CSS, NativeMML (i.e. MathML) and
+# SVG. The default value is HTML-CSS, which is slower, but has the best
+# compatibility.
+
+MATHJAX_FORMAT         = HTML-CSS
+
 # When MathJax is enabled you need to specify the location relative to the
 # HTML output directory using the MATHJAX_RELPATH option. The destination
 # directory should contain the MathJax.js script. For instance, if the mathjax
 # directory is located at the same level as the HTML output directory, then
 # MATHJAX_RELPATH should be ../mathjax. The default value points to
 # the MathJax Content Delivery Network so you can quickly see the result without
-# installing MathJax.  However, it is strongly recommended to install a local
+# installing MathJax.
+# However, it is strongly recommended to install a local
 # copy of MathJax from http://www.mathjax.org before deployment.
 
 MATHJAX_RELPATH        = http://cdn.mathjax.org/mathjax/latest
@@ -1233,6 +1266,11 @@
 
 MATHJAX_EXTENSIONS     =
 
+# The MATHJAX_CODEFILE tag can be used to specify a file with javascript
+# pieces of code that will be used on startup of the MathJax code.
+
+MATHJAX_CODEFILE       =
+
 # When the SEARCHENGINE tag is enabled doxygen will generate a search box
 # for the HTML output. The underlying search engine uses javascript
 # and DHTML and should work on any modern browser. Note that when using
@@ -1244,15 +1282,55 @@
 SEARCHENGINE           = YES
 
 # When the SERVER_BASED_SEARCH tag is enabled the search engine will be
-# implemented using a PHP enabled web server instead of at the web client
-# using Javascript. Doxygen will generate the search PHP script and index
-# file to put on the web server. The advantage of the server
-# based approach is that it scales better to large projects and allows
-# full text search. The disadvantages are that it is more difficult to setup
-# and does not have live searching capabilities.
+# implemented using a web server instead of a web client using Javascript.
+# There are two flavours of web server based search depending on the
+# EXTERNAL_SEARCH setting. When disabled, doxygen will generate a PHP script for
+# searching and an index file used by the script. When EXTERNAL_SEARCH is
+# enabled the indexing and searching needs to be provided by external tools.
+# See the manual for details.
 
 SERVER_BASED_SEARCH    = NO
 
+# When EXTERNAL_SEARCH is enabled doxygen will no longer generate the PHP
+# script for searching. Instead the search results are written to an XML file
+# which needs to be processed by an external indexer. Doxygen will invoke an
+# external search engine pointed to by the SEARCHENGINE_URL option to obtain
+# the search results. Doxygen ships with an example indexer (doxyindexer) and
+# search engine (doxysearch.cgi) which are based on the open source search
+# engine library Xapian. See the manual for configuration details.
+
+EXTERNAL_SEARCH        = NO
+
+# The SEARCHENGINE_URL should point to a search engine hosted by a web server
+# which will returned the search results when EXTERNAL_SEARCH is enabled.
+# Doxygen ships with an example search engine (doxysearch) which is based on
+# the open source search engine library Xapian. See the manual for configuration
+# details.
+
+SEARCHENGINE_URL       =
+
+# When SERVER_BASED_SEARCH and EXTERNAL_SEARCH are both enabled the unindexed
+# search data is written to a file for indexing by an external tool. With the
+# SEARCHDATA_FILE tag the name of this file can be specified.
+
+SEARCHDATA_FILE        = searchdata.xml
+
+# When SERVER_BASED_SEARCH AND EXTERNAL_SEARCH are both enabled the
+# EXTERNAL_SEARCH_ID tag can be used as an identifier for the project. This is
+# useful in combination with EXTRA_SEARCH_MAPPINGS to search through multiple
+# projects and redirect the results back to the right project.
+
+EXTERNAL_SEARCH_ID     =
+
+# The EXTRA_SEARCH_MAPPINGS tag can be used to enable searching through doxygen
+# projects other than the one defined by this configuration file, but that are
+# all added to the same external search index. Each project needs to have a
+# unique id set via EXTERNAL_SEARCH_ID. The search mapping then maps the id
+# of to a relative location where the documentation can be found.
+# The format is: EXTRA_SEARCH_MAPPINGS = id1=loc1 id2=loc2 ...
+
+EXTRA_SEARCH_MAPPINGS  =
+
 #---------------------------------------------------------------------------
 # configuration options related to the LaTeX output
 #---------------------------------------------------------------------------
@@ -1290,7 +1368,7 @@
 
 # The PAPER_TYPE tag can be used to set the paper type that is used
 # by the printer. Possible values are: a4, letter, legal and
-# executive. If left blank a4wide will be used.
+# executive. If left blank a4 will be used.
 
 PAPER_TYPE             = a4
 
@@ -1313,6 +1391,13 @@
 
 LATEX_FOOTER           =
 
+# The LATEX_EXTRA_FILES tag can be used to specify one or more extra images
+# or other source files which should be copied to the LaTeX output directory.
+# Note that the files will be copied as-is; there are no commands or markers
+# available.
+
+LATEX_EXTRA_FILES      =
+
 # If the PDF_HYPERLINKS tag is set to YES, the LaTeX that is generated
 # is prepared for conversion to pdf (using ps2pdf). The pdf file will
 # contain links (just like the HTML output) instead of page references
@@ -1458,6 +1543,21 @@
 XML_PROGRAMLISTING     = YES
 
 #---------------------------------------------------------------------------
+# configuration options related to the DOCBOOK output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_DOCBOOK tag is set to YES Doxygen will generate DOCBOOK files
+# that can be used to generate PDF.
+
+GENERATE_DOCBOOK       = NO
+
+# The DOCBOOK_OUTPUT tag is used to specify where the DOCBOOK pages will be put.
+# If a relative path is entered the value of OUTPUT_DIRECTORY will be put in
+# front of it. If left blank docbook will be used as the default path.
+
+DOCBOOK_OUTPUT         = docbook
+
+#---------------------------------------------------------------------------
 # configuration options for the AutoGen Definitions output
 #---------------------------------------------------------------------------
 
@@ -1488,8 +1588,10 @@
 PERLMOD_LATEX          = NO
 
 # If the PERLMOD_PRETTY tag is set to YES the Perl module output will be
-# nicely formatted so it can be parsed by a human reader.  This is useful
-# if you want to understand what is going on.  On the other hand, if this
+# nicely formatted so it can be parsed by a human reader.
+# This is useful
+# if you want to understand what is going on.
+# On the other hand, if this
 # tag is set to NO the size of the Perl module output will be much smaller
 # and Perl will parse it just the same.
 
@@ -1575,9 +1677,11 @@
 # The TAGFILES option can be used to specify one or more tagfiles. For each
 # tag file the location of the external documentation should be added. The
 # format of a tag file without this location is as follows:
-#   TAGFILES = file1 file2 ...
+#
+# TAGFILES = file1 file2 ...
 # Adding location for the tag files is done as follows:
-#   TAGFILES = file1=loc1 "file2 = loc2" ...
+#
+# TAGFILES = file1=loc1 "file2 = loc2" ...
 # where "loc1" and "loc2" can be relative or absolute paths
 # or URLs. Note that each tag file must have a unique name (where the name does
 # NOT include the path). If a tag file is not located in the directory in which
@@ -1602,6 +1706,12 @@
 
 EXTERNAL_GROUPS        = YES
 
+# If the EXTERNAL_PAGES tag is set to YES all external pages will be listed
+# in the related pages index. If set to NO, only the current project's
+# pages will be listed.
+
+EXTERNAL_PAGES         = YES
+
 # The PERL_PATH should be the absolute path and name of the perl script
 # interpreter (i.e. the result of `which perl').
 
@@ -1698,7 +1808,7 @@
 # the class node. If there are many fields or methods and many nodes the
 # graph may become too big to be useful. The UML_LIMIT_NUM_FIELDS
 # threshold limits the number of items for each type to make the size more
-# managable. Set this to 0 for no limit. Note that the threshold may be
+# manageable. Set this to 0 for no limit. Note that the threshold may be
 # exceeded by 50% before the limit is enforced.
 
 UML_LIMIT_NUM_FIELDS   = 10

=== modified file 'doc/component_reports.md'
--- doc/component_reports.md	2013-11-06 03:17:35 +0000
+++ doc/component_reports.md	2013-11-25 03:07:43 +0000
@@ -24,7 +24,7 @@
 legacy-input-report     | log
 msg-processor-report    | log,lttng
 session-mediator-report | log
-surfaces-report         | log
+scene-report            | log
 
 For example, to enable the LTTng input report, one could either use the
 `--input-report=lttng` command-line option to the server, or set the
@@ -40,6 +40,7 @@
 Report              | Handlers
 ------------------- | --------
 rpc-report          | log,lttng
+input-receiver      | log
 
 For example, to enable the logging RPC report, one should set the
 `MIR_CLIENT_RPC_REPORT=log` environment variable.

=== modified file 'doc/installing_prebuilt_on_pc.md'
--- doc/installing_prebuilt_on_pc.md	2013-11-06 03:17:35 +0000
+++ doc/installing_prebuilt_on_pc.md	2013-11-25 03:07:43 +0000
@@ -4,7 +4,12 @@
 Install Ubuntu 13.10 or later if you haven't done so already.  Uninstall any
 proprietary drivers (-nvidia, -fglrx) and reboot on the FOSS drivers.
 
-Install Mir:
+Install Mir in Ubuntu 13.10:
 
        sudo apt-get update
        sudo apt-get install mir-demos unity-system-compositor
+
+Install Mir in Ubuntu 14.04 or later:
+
+       sudo apt-get update
+       sudo apt-get install mir-demos ubuntu-desktop-mir

=== modified file 'doc/using_mir_on_pc.md'
--- doc/using_mir_on_pc.md	2013-11-06 03:17:35 +0000
+++ doc/using_mir_on_pc.md	2013-11-25 03:07:43 +0000
@@ -31,12 +31,14 @@
 include lightdm, Mesa and the Xorg drivers). The easiest way is to run Ubuntu
 13.10 or later.
 
-If you have installed unity-system-compositor it will have created a file in
-/etc/lightdm/lightdm.conf.d/10-unity-system-compositor.conf to run XMir. If you
-have build from source, to run X sessions under Mir, with Mir acting as the
-system compositor, create the file
-/etc/lightdm/lightdm.conf.d/10-unity-system-compositor.conf to look to look like
-this:
+If you are running Ubuntu 13.10, additionally install unity-system-compositor.
+If you are running Ubuntu 14.04 or later, instead install ubuntu-desktop-mir.
+These packages will install dependencies you need and will create a file in
+/etc/lightdm/lightdm.conf.d/10-unity-system-compositor.conf.
+
+If you have instead built from source, to set up the system compositor, create
+/etc/lightdm/lightdm.conf.d/10-unity-system-compositor.conf yourself and make
+it look like this:
 
     [SeatDefaults]
     type=unity

=== modified file 'examples/CMakeLists.txt'
--- examples/CMakeLists.txt	2013-09-23 13:37:44 +0000
+++ examples/CMakeLists.txt	2013-11-25 03:07:43 +0000
@@ -114,6 +114,7 @@
 target_link_libraries(mir_demo_standalone_render_surfaces
     mirserver
     mirshell
+    mirsharedgeometry
     ${Boost_LIBRARIES}
 )
 

=== modified file 'examples/buffer_render_target.cpp'
--- examples/buffer_render_target.cpp	2013-08-28 03:41:48 +0000
+++ examples/buffer_render_target.cpp	2013-11-25 03:07:43 +0000
@@ -27,7 +27,7 @@
 namespace mt = mir::tools;
 
 mt::BufferRenderTarget::BufferRenderTarget(mg::Buffer& buffer)
-    : buffer(buffer)
+    : buffer(buffer), old_fbo(), old_viewport()
 {
     /*
      * With the new lazy buffer allocation method, we may be executing inside
@@ -35,12 +35,14 @@
      * we change...
      */
     glGetIntegerv(GL_VIEWPORT, old_viewport);
+    glGetIntegerv(GL_FRAMEBUFFER_BINDING, &old_fbo);
     resources.setup(buffer);
 }
 
 mt::BufferRenderTarget::~BufferRenderTarget()
 {
     glFinish();
+    glBindFramebuffer(GL_FRAMEBUFFER, old_fbo);
     glViewport(old_viewport[0], old_viewport[1],
                old_viewport[2], old_viewport[3]);
 }

=== modified file 'examples/buffer_render_target.h'
--- examples/buffer_render_target.h	2013-08-28 03:41:48 +0000
+++ examples/buffer_render_target.h	2013-11-25 03:07:43 +0000
@@ -58,6 +58,7 @@
 
     Resources resources;
     mir::graphics::Buffer& buffer;
+    GLint old_fbo;
     GLint old_viewport[4];
 };
 

=== modified file 'examples/demo-inprocess-surface-client/inprocess_egl_client.cpp'
--- examples/demo-inprocess-surface-client/inprocess_egl_client.cpp	2013-11-06 03:17:35 +0000
+++ examples/demo-inprocess-surface-client/inprocess_egl_client.cpp	2013-11-25 03:07:43 +0000
@@ -21,7 +21,7 @@
 
 #include "mir/main_loop.h"
 #include "mir/shell/focus_controller.h"
-#include "mir/shell/surface.h"
+#include "mir/frontend/surface.h"
 #include "mir/shell/surface_creation_parameters.h"
 #include "mir/shell/session.h"
 #include "mir/frontend/session.h"
@@ -47,7 +47,6 @@
 #include <signal.h>
 
 namespace mf = mir::frontend;
-namespace mc = mir::compositor;
 namespace msh = mir::shell;
 namespace mg = mir::graphics;
 namespace me = mir::examples;

=== modified file 'examples/demo-shell/demo_shell.cpp'
--- examples/demo-shell/demo_shell.cpp	2013-11-06 03:17:35 +0000
+++ examples/demo-shell/demo_shell.cpp	2013-11-25 03:07:43 +0000
@@ -24,7 +24,6 @@
 
 #include "mir/run_mir.h"
 #include "mir/report_exception.h"
-#include "mir/shell/session_container.h"
 #include "mir/graphics/display.h"
 #include "mir/input/composite_event_filter.h"
 

=== modified file 'examples/demo-shell/window_manager.cpp'
--- examples/demo-shell/window_manager.cpp	2013-11-06 03:17:35 +0000
+++ examples/demo-shell/window_manager.cpp	2013-11-25 03:07:43 +0000
@@ -14,6 +14,7 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  *
  * Authored by: Robert Carr <[e-mail]>
+ *              Daniel van Vugt <[e-mail]>
  */
 
 #include "window_manager.h"
@@ -29,6 +30,7 @@
 
 #include <cassert>
 #include <cstdlib>
+#include <cmath>
 
 namespace me = mir::examples;
 namespace msh = mir::shell;
@@ -41,7 +43,7 @@
 }
 
 me::WindowManager::WindowManager()
-    : max_fingers(0)
+    : old_pinch_diam(0.0f), max_fingers(0)
 {
 }
 
@@ -60,6 +62,9 @@
     compositor = cptor;
 }
 
+namespace
+{
+
 mir::geometry::Point average_pointer(MirMotionEvent const& motion)
 {
     using namespace mir;
@@ -79,6 +84,36 @@
     return Point{x, y};
 }
 
+float measure_pinch(MirMotionEvent const& motion,
+                    mir::geometry::Displacement& dir)
+{
+    int count = static_cast<int>(motion.pointer_count);
+    int max = 0;
+
+    for (int i = 0; i < count; i++)
+    {
+        for (int j = 0; j < i; j++)
+        {
+            int dx = motion.pointer_coordinates[i].x -
+                     motion.pointer_coordinates[j].x;
+            int dy = motion.pointer_coordinates[i].y -
+                     motion.pointer_coordinates[j].y;
+
+            int sqr = dx*dx + dy*dy;
+
+            if (sqr > max)
+            {
+                max = sqr;
+                dir = mir::geometry::Displacement{dx, dy};
+            }
+        }
+    }
+
+    return sqrtf(max);  // return pinch diameter
+}
+
+} // namespace
+
 bool me::WindowManager::handle(MirEvent const& event)
 {
     // TODO: Fix android configuration and remove static hack ~racarr
@@ -87,6 +122,8 @@
     assert(display);
     assert(compositor);
 
+    bool handled = false;
+
     if (event.key.type == mir_event_type_key &&
         event.key.action == mir_key_action_down)
     {
@@ -148,22 +185,73 @@
                 (event.motion.modifiers & mir_key_modifier_alt ||
                  fingers >= 3))
             {
+                geometry::Displacement pinch_dir;
+                auto pinch_diam =
+                    measure_pinch(event.motion, pinch_dir);
+
                 // Start of a gesture: When the latest finger/button goes down
                 if (action == mir_motion_action_down ||
                     action == mir_motion_action_pointer_down)
                 {
-                    relative_click = cursor - surf->top_left();
                     click = cursor;
-                }
-                else if (event.motion.action == mir_motion_action_move)
-                { // Movement is happening with one or more fingers/button down
-                    geometry::Point abs = cursor - relative_click;
-                    if (max_fingers <= 3)  // Avoid accidental movement
-                    {
-                        surf->move_to(abs);
-                        return true;
-                    }
-                }
+                    handled = true;
+                }
+                else if (event.motion.action == mir_motion_action_move &&
+                         max_fingers <= 3)  // Avoid accidental movement
+                {
+                    geometry::Displacement drag = cursor - old_cursor;
+
+                    if (event.motion.button_state ==
+                        mir_motion_button_tertiary)
+                    {  // Resize by mouse middle button
+                        int width = old_size.width.as_int() +
+                                    drag.dx.as_int();
+                        int height = old_size.height.as_int() +
+                                     drag.dy.as_int();
+                        if (width <= 0) width = 1;
+                        if (height <= 0) height = 1; 
+                        surf->resize({width, height});
+                    }
+                    else
+                    { // Move surface (by mouse or 3 fingers)
+                        surf->move_to(old_pos + drag);
+                    }
+
+                    if (fingers == 3)
+                    {  // Resize by pinch/zoom
+                        float diam_delta = pinch_diam - old_pinch_diam;
+                        /*
+                         * Resize vector (dx,dy) has length=diam_delta and
+                         * direction=pinch_dir, so solve for (dx,dy)...
+                         */
+                        float lenlen = diam_delta * diam_delta;
+                        int x = pinch_dir.dx.as_int();
+                        int y = pinch_dir.dy.as_int();
+                        int xx = x * x;
+                        int yy = y * y;
+                        int xxyy = xx + yy;
+                        int dx = sqrtf(lenlen * xx / xxyy);
+                        int dy = sqrtf(lenlen * yy / xxyy);
+                        if (diam_delta < 0.0f)
+                        {
+                            dx = -dx;
+                            dy = -dy;
+                        }
+
+                        int width = old_size.width.as_int() + dx;
+                        int height = old_size.height.as_int() + dy;
+                        if (width <= 0) width = 1; 
+                        if (height <= 0) height = 1; 
+                        surf->resize({width, height});
+                    }
+
+                    handled = true;
+                }
+
+                old_pos = surf->top_left();
+                old_size = surf->size();
+                old_pinch_diam = pinch_diam;
+                old_cursor = cursor;
             }
         }
 
@@ -173,9 +261,9 @@
             if (abs(dir.dx.as_int()) >= min_swipe_distance)
             {
                 focus_controller->focus_next();
-                return true;
+                handled = true;
             }
         }
     }
-    return false;
+    return handled;
 }

=== modified file 'examples/demo-shell/window_manager.h'
--- examples/demo-shell/window_manager.h	2013-11-06 03:17:35 +0000
+++ examples/demo-shell/window_manager.h	2013-11-25 03:07:43 +0000
@@ -21,6 +21,7 @@
 
 #include "mir/input/event_filter.h"
 #include "mir/geometry/displacement.h"
+#include "mir/geometry/size.h"
 
 #include <memory>
 
@@ -62,8 +63,11 @@
     std::shared_ptr<graphics::Display> display;
     std::shared_ptr<compositor::Compositor> compositor;
 
-    geometry::Displacement relative_click;  // Click location in window space
-    geometry::Point click;                  // Click location in screen space
+    geometry::Point click;
+    geometry::Point old_pos;
+    geometry::Point old_cursor;
+    geometry::Size old_size;
+    float old_pinch_diam;
     int max_fingers;  // Maximum number of fingers touched during gesture
 };
 

=== modified file 'examples/demo_input_filter.cpp'
--- examples/demo_input_filter.cpp	2013-08-28 03:41:48 +0000
+++ examples/demo_input_filter.cpp	2013-11-25 03:07:43 +0000
@@ -32,6 +32,21 @@
 
 struct PrintingEventFilter : public mi::EventFilter
 {
+    void print_motion_event(MirMotionEvent const& ev)
+    {
+        std::cout << "Motion Event time=" << ev.event_time
+            << " pointer_count=" << ev.pointer_count << std::endl;
+
+        for (size_t i = 0; i < ev.pointer_count; ++i)
+        {
+            std::cout << "  "
+                << " id=" << ev.pointer_coordinates[i].id
+                << " pos=(" << ev.pointer_coordinates[i].x << ", " << ev.pointer_coordinates[i].y << ")"
+                << std::endl;
+        }
+        std::cout << "----------------" << std::endl << std::endl;
+    }
+
     bool handle(MirEvent const& ev) override
     {
         // TODO: Enhance printing
@@ -42,8 +57,7 @@
         }
         else if (ev.type == mir_event_type_motion)
         {
-            std::cout << "Handling motion event (time, pointer0_x, pointer0_y): " << ev.motion.event_time << " "
-                << ev.motion.pointer_coordinates[0].x << " " << ev.motion.pointer_coordinates[0].y << std::endl;
+            print_motion_event(ev.motion);
         }
         return false;
     }
@@ -56,7 +70,7 @@
         event_filter(std::make_shared<PrintingEventFilter>())
     {
     }
-    
+
     std::shared_ptr<mi::CompositeEventFilter> the_composite_event_filter() override
     {
         auto composite_filter = ServerConfiguration::the_composite_event_filter();
@@ -69,10 +83,18 @@
 
 }
 
+
+#include <std/MirLog.h>
+void my_write_to_log(int /*prio*/, char const* buffer)
+{
+    printf("%s\n", buffer);
+}
+
 int main(int argc, char const* argv[])
 try
 {
     DemoServerConfiguration config(argc, argv);
+    mir::write_to_log = my_write_to_log;
 
     mir::run_mir(config, [](mir::DisplayServer&) {/* empty init */});
     return 0;

=== modified file 'examples/eglapp.c'
--- examples/eglapp.c	2013-10-07 09:21:27 +0000
+++ examples/eglapp.c	2013-11-25 03:07:43 +0000
@@ -23,6 +23,7 @@
 #include <signal.h>
 #include <time.h>
 #include <EGL/egl.h>
+#include <GLES2/gl2.h>
 
 #include <xkbcommon/xkbcommon-keysyms.h>
 
@@ -75,6 +76,7 @@
     time_t now = time(NULL);
     time_t dtime;
     int dcount;
+    EGLint width, height;
 
     if (!running)
         return;
@@ -90,6 +92,14 @@
         lasttime = now;
         lastcount = count;
     }
+
+    /* This is one way to handle window resizing. But in future it would be
+       better to have resize events coming from the server */
+    if (eglQuerySurface(egldisplay, eglsurface, EGL_WIDTH, &width) &&
+        eglQuerySurface(egldisplay, eglsurface, EGL_HEIGHT, &height))
+    {
+        glViewport(0, 0, width, height);
+    }
 }
 
 static void mir_eglapp_handle_input(MirSurface* surface, MirEvent const* ev, void* context)
@@ -300,12 +310,11 @@
 
     const MirDisplayMode *mode = &output->modes[output->current_mode];
 
-    const unsigned int max_formats = 10;
-    unsigned int format[max_formats];
+    unsigned int format[mir_pixel_formats];
     unsigned int nformats;
 
     mir_connection_get_available_surface_formats(connection,
-        format, max_formats, &nformats);
+        format, mir_pixel_formats, &nformats);
 
     surfaceparm.pixel_format = format[0];
     for (unsigned int f = 0; f < nformats; f++)
@@ -322,18 +331,17 @@
         }
     }
 
-    printf("Connected to display: resolution (%dx%d), position(%dx%d), "
-           "supports %d pixel formats\n",
+    printf("Current active output is %dx%d %+d%+d\n",
            mode->horizontal_resolution, mode->vertical_resolution,
-           output->position_x, output->position_y,
-           output->num_output_formats);
+           output->position_x, output->position_y);
 
     surfaceparm.width = *width > 0 ? *width : mode->horizontal_resolution;
     surfaceparm.height = *height > 0 ? *height : mode->vertical_resolution;
 
     mir_display_config_destroy(display_config);
 
-    printf("Using pixel format #%d\n", surfaceparm.pixel_format);
+    printf("Server supports %d of %d surface pixel formats. Using format: %d\n",
+        nformats, mir_pixel_formats, surfaceparm.pixel_format);
     unsigned int bpp = get_bpp(surfaceparm.pixel_format);
     EGLint attribs[] =
     {

=== modified file 'examples/progressbar.c'
--- examples/progressbar.c	2013-08-27 08:52:43 +0000
+++ examples/progressbar.c	2013-11-25 03:07:43 +0000
@@ -33,6 +33,12 @@
     uint8_t r, g, b, a;
 } Color;
 
+static const Color blue = {0, 0, 255, 255};
+static const Color white = {255, 255, 255, 255};
+
+static const Color *const foreground = &white;
+static const Color *const background = &blue;
+
 static volatile sig_atomic_t running = 1;
 
 static void shutdown(int signum)
@@ -178,6 +184,7 @@
     MirGraphicsRegion backbuffer;
 
     mir_surface_get_graphics_region(surface, &backbuffer);
+    clear_region(&backbuffer, background);
     copy_region(&backbuffer, canvas);
     mir_surface_swap_buffers_sync(surface);
 }
@@ -264,8 +271,6 @@
         
             while (running)
             {
-                static const Color background = {0, 0, 255, 255};
-                static const Color foreground = {255, 255, 255, 255};
                 static const int width = 8;
                 static const int space = 1;
                 const int grid = width + 2 * space;
@@ -275,11 +280,11 @@
                 const int y = (t / row) * grid + space;
 
                 if (t % square == 0)
-                    clear_region(&canvas, &background);
+                    clear_region(&canvas, background);
 
                 t = (t + 1) % square;
 
-                draw_box(&canvas, x, y, width, &foreground);
+                draw_box(&canvas, x, y, width, foreground);
 
                 redraw(surf, &canvas);
                 usleep(sleep_usec);

=== modified file 'examples/render_surfaces.cpp'
--- examples/render_surfaces.cpp	2013-11-06 03:17:35 +0000
+++ examples/render_surfaces.cpp	2013-11-25 03:07:43 +0000
@@ -27,8 +27,8 @@
 #include "mir/graphics/cursor.h"
 #include "mir/graphics/display.h"
 #include "mir/graphics/display_buffer.h"
-#include "mir/shell/surface_builder.h"
-#include "mir/surfaces/surface.h"
+#include "mir/shell/surface_factory.h"
+#include "mir/shell/surface.h"
 #include "mir/run_mir.h"
 #include "mir/report_exception.h"
 
@@ -49,7 +49,7 @@
 
 namespace mg = mir::graphics;
 namespace mc = mir::compositor;
-namespace ms = mir::surfaces;
+namespace ms = mir::scene;
 namespace mf = mir::frontend;
 namespace msh = mir::shell;
 namespace mi = mir::input;
@@ -185,13 +185,13 @@
 {
 public:
     Moveable() {}
-    Moveable(ms::Surface& s, const geom::Size& display_size,
+    Moveable(std::shared_ptr<msh::Surface> const& s, const geom::Size& display_size,
              float dx, float dy, const glm::vec3& rotation_axis, float alpha_offset)
-        : surface(&s), display_size(display_size),
-          x{static_cast<float>(s.top_left().x.as_uint32_t())},
-          y{static_cast<float>(s.top_left().y.as_uint32_t())},
-          w{static_cast<float>(s.size().width.as_uint32_t())},
-          h{static_cast<float>(s.size().height.as_uint32_t())},
+        : surface(s), display_size(display_size),
+          x{static_cast<float>(s->top_left().x.as_uint32_t())},
+          y{static_cast<float>(s->top_left().y.as_uint32_t())},
+          w{static_cast<float>(s->size().width.as_uint32_t())},
+          h{static_cast<float>(s->size().height.as_uint32_t())},
           dx{dx},
           dy{dy},
           rotation_axis{rotation_axis},
@@ -233,7 +233,7 @@
     }
 
 private:
-    ms::Surface* surface;
+    std::shared_ptr<msh::Surface> surface;
     geom::Size display_size;
     float x;
     float y;
@@ -387,7 +387,7 @@
         std::cout << "Rendering " << moveables.size() << " surfaces" << std::endl;
 
         auto const display = the_display();
-        auto const surface_builder = the_surface_builder();
+        auto const surface_factory = the_scene_surface_factory();
         /* TODO: Get proper configuration */
         geom::Rectangles view_area;
         display->for_each_display_buffer([&view_area](mg::DisplayBuffer const& db)
@@ -406,18 +406,20 @@
         int i = 0;
         for (auto& m : moveables)
         {
-            std::shared_ptr<ms::Surface> s = surface_builder->create_surface(
+            auto const s = surface_factory->create_surface(
                     nullptr,
                     msh::a_surface().of_size(surface_size)
                                    .of_pixel_format(surface_pf)
-                                   .of_buffer_usage(mg::BufferUsage::hardware)
-                    ).lock();
+                                   .of_buffer_usage(mg::BufferUsage::hardware),
+                    mf::SurfaceId(), {});
 
             /*
-             * Let the system know that the surface is suitable for rendering
-             * (i.e., that it contains buffers with valid contents).
+             * We call advance_client_buffer() twice so that the surface is
+             * considers the first buffer to be posted.
+             * (TODO There must be a better way!)
              */
-            s->flag_for_render();
+            s->advance_client_buffer();
+            s->advance_client_buffer();
 
             /*
              * Place each surface at a different starting location and give it a
@@ -427,7 +429,7 @@
             uint32_t const y = h * (0.5 + 0.25 * sin(i * angular_step)) - surface_side / 2.0;
 
             s->move_to({x, y});
-            m = Moveable(*s, display_size,
+            m = Moveable(s, display_size,
                     cos(0.1f + i * M_PI / 6.0f) * w / 3.0f,
                     sin(0.1f + i * M_PI / 6.0f) * h / 3.0f,
                     glm::vec3{(i % 3 == 0) * 1.0f, (i % 3 == 1) * 1.0f, (i % 3 == 2) * 1.0f},

=== modified file 'include/client/mir_toolkit/mir_client_library.h'
--- include/client/mir_toolkit/mir_client_library.h	2013-08-28 03:41:48 +0000
+++ include/client/mir_toolkit/mir_client_library.h	2013-11-25 03:07:43 +0000
@@ -207,7 +207,7 @@
 /**
  * Set the event handler to be called when events arrive for a surface.
  *   \warning event_handler could be called from another thread. You must do
- *            and locking appropriate to protect your data accessed in the
+ *            any locking appropriate to protect your data accessed in the
  *            callback. There is also a chance that different events will be
  *            called back in different threads, for the same surface,
  *            simultaneously.

=== added file 'include/platform/mir/graphics/basic_platform.h'
--- include/platform/mir/graphics/basic_platform.h	1970-01-01 00:00:00 +0000
+++ include/platform/mir/graphics/basic_platform.h	2013-11-25 03:07:43 +0000
@@ -0,0 +1,45 @@
+/*
+ * Copyright © 2013 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License version 3,
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Alexandros Frantzis <[e-mail]>
+ */
+
+#ifndef MIR_GRAPHICS_BASIC_PLATFORM_H_
+#define MIR_GRAPHICS_BASIC_PLATFORM_H_
+
+#include <EGL/egl.h>
+
+namespace mir
+{
+namespace graphics
+{
+
+class BasicPlatform
+{
+public:
+    virtual ~BasicPlatform() = default;
+
+    virtual EGLNativeDisplayType egl_native_display() const = 0;
+
+protected:
+    BasicPlatform() = default;
+    BasicPlatform(BasicPlatform const&) = delete;
+    BasicPlatform& operator=(BasicPlatform const&) = delete;
+};
+
+}
+}
+
+#endif /* MIR_GRAPHICS_BASIC_PLATFORM_H_ */

=== modified file 'include/platform/mir/graphics/buffer_ipc_packer.h'
--- include/platform/mir/graphics/buffer_ipc_packer.h	2013-09-11 05:21:22 +0000
+++ include/platform/mir/graphics/buffer_ipc_packer.h	2013-11-25 03:07:43 +0000
@@ -20,6 +20,7 @@
 #define MIR_GRAPHICS_BUFFER_IPC_PACKER_H_
 
 #include "mir/geometry/dimensions.h"
+#include "mir/geometry/size.h"
 
 namespace mir
 {
@@ -34,6 +35,7 @@
     virtual void pack_data(int) = 0;
     virtual void pack_stride(geometry::Stride) = 0;
     virtual void pack_flags(unsigned int) = 0;
+    virtual void pack_size(geometry::Size const& size) = 0;
 
 protected:
     BufferIPCPacker() {}

=== modified file 'include/platform/mir/graphics/egl_resources.h'
--- include/platform/mir/graphics/egl_resources.h	2013-08-28 03:41:48 +0000
+++ include/platform/mir/graphics/egl_resources.h	2013-11-25 03:07:43 +0000
@@ -30,6 +30,8 @@
 {
 public:
     EGLContextStore(EGLDisplay egl_display, EGLContext egl_context);
+    EGLContextStore(EGLContextStore&&);
+
     ~EGLContextStore() noexcept;
 
     operator EGLContext() const;
@@ -38,14 +40,18 @@
     EGLContextStore(EGLContextStore const&) = delete;
     EGLContextStore& operator=(EGLContextStore const&) = delete;
 
-    EGLDisplay const egl_display_;
-    EGLContext const egl_context_;
+    EGLDisplay egl_display_;
+    EGLContext egl_context_;
 };
 
 class EGLSurfaceStore
 {
 public:
+    enum AllowNoSurface { DisallowNoSurface, AllowNoSurface };
+    EGLSurfaceStore(EGLDisplay egl_display, EGLSurface egl_surface,
+                    enum AllowNoSurface allow_no_surface);
     EGLSurfaceStore(EGLDisplay egl_display, EGLSurface egl_surface);
+    EGLSurfaceStore(EGLSurfaceStore&&);
 
     ~EGLSurfaceStore() noexcept;
 
@@ -55,8 +61,8 @@
     EGLSurfaceStore(EGLSurfaceStore const&) = delete;
     EGLSurfaceStore& operator=(EGLSurfaceStore const&) = delete;
 
-    EGLDisplay const egl_display_;
-    EGLSurface const egl_surface_;
+    EGLDisplay egl_display_;
+    EGLSurface egl_surface_;
 };
 
 }

=== modified file 'include/platform/mir/graphics/native_platform.h'
--- include/platform/mir/graphics/native_platform.h	2013-10-23 09:33:59 +0000
+++ include/platform/mir/graphics/native_platform.h	2013-11-25 03:07:43 +0000
@@ -52,7 +52,7 @@
 
     virtual std::shared_ptr<InternalClient> create_internal_client() = 0;
 
-    virtual void fill_ipc_package(std::shared_ptr<BufferIPCPacker> const& packer, std::shared_ptr<Buffer> const& buffer) const = 0;
+    virtual void fill_ipc_package(BufferIPCPacker* packer, Buffer const* buffer) const = 0;
 
     virtual ~NativePlatform() = default;
     NativePlatform(NativePlatform const&) = delete;

=== modified file 'include/platform/mir/graphics/platform.h'
--- include/platform/mir/graphics/platform.h	2013-08-28 03:41:48 +0000
+++ include/platform/mir/graphics/platform.h	2013-11-25 03:07:43 +0000
@@ -20,6 +20,8 @@
 #ifndef MIR_GRAPHICS_PLATFORM_H_
 #define MIR_GRAPHICS_PLATFORM_H_
 
+#include "basic_platform.h"
+
 #include <memory>
 
 namespace mir
@@ -57,7 +59,7 @@
  * Interface to platform specific support for graphics operations.
  * \ingroup platform_enablement
  */
-class Platform
+class Platform : public BasicPlatform
 {
 public:
     Platform() = default;
@@ -97,8 +99,7 @@
      * \param [in] packer the object providing the packing functionality
      * \param [in] buffer the buffer to fill the IPC package for
      */
-    virtual void fill_ipc_package(std::shared_ptr<BufferIPCPacker> const& packer,
-                                  std::shared_ptr<graphics::Buffer> const& buffer) const = 0;
+    virtual void fill_ipc_package(BufferIPCPacker* packer, Buffer const* buffer) const = 0;
 
     /**
      * Creates the in-process client support object.

=== modified file 'include/server/mir/compositor/buffer_stream.h'
--- include/server/mir/compositor/buffer_stream.h	2013-11-06 03:17:35 +0000
+++ include/server/mir/compositor/buffer_stream.h	2013-11-25 03:07:43 +0000
@@ -47,6 +47,7 @@
     virtual std::shared_ptr<graphics::Buffer> lock_snapshot_buffer() = 0;
     virtual geometry::PixelFormat get_stream_pixel_format() = 0;
     virtual geometry::Size stream_size() = 0;
+    virtual void resize(geometry::Size const& size) = 0;
     virtual void allow_framedropping(bool) = 0;
     virtual void force_requests_to_complete() = 0;
 };

=== modified file 'include/server/mir/compositor/scene.h'
--- include/server/mir/compositor/scene.h	2013-11-06 03:17:35 +0000
+++ include/server/mir/compositor/scene.h	2013-11-25 03:07:43 +0000
@@ -75,7 +75,7 @@
      * Scene changes.
      *
      * The supplied callback should not directly or indirectly (e.g.,
-     * by changing a property of a Renderable) change the state of
+     * by changing a property of a surface) change the state of
      * the Scene, otherwise a deadlock may occur.
      */
     virtual void set_change_callback(std::function<void()> const& f) = 0;

=== modified file 'include/server/mir/default_configuration_options.h'
--- include/server/mir/default_configuration_options.h	2013-11-06 03:17:35 +0000
+++ include/server/mir/default_configuration_options.h	2013-11-25 03:07:43 +0000
@@ -35,12 +35,13 @@
     static char const* const display_report_opt;
     static char const* const legacy_input_report_opt;
     static char const* const connector_report_opt;
-    static char const* const surfaces_report_opt;
+    static char const* const scene_report_opt;
     static char const* const input_report_opt;
     static char const* const host_socket_opt;
     static char const* const standalone_opt;
     static char const* const frontend_threads;
     static char const* const name_opt;
+    static char const* const offscreen_opt;
 
     static char const* const glog;
     static char const* const glog_stderrthreshold;

=== modified file 'include/server/mir/default_server_configuration.h'
--- include/server/mir/default_server_configuration.h	2013-11-06 03:17:35 +0000
+++ include/server/mir/default_server_configuration.h	2013-11-25 03:07:43 +0000
@@ -55,37 +55,36 @@
 namespace shell
 {
 class SurfaceFactory;
-class SurfaceBuilder;
 class SurfaceController;
 class InputTargeter;
-class SessionContainer;
 class FocusSetter;
-class FocusSequence;
 class PlacementStrategy;
 class SessionListener;
 class FocusController;
-class SessionManager;
-class PixelBuffer;
-class SnapshotStrategy;
 class DisplayLayout;
 class SurfaceConfigurator;
+}
+namespace time
+{
+class TimeSource;
+}
+namespace scene
+{
+class BroadcastingSessionEventSink;
+class BufferStreamFactory;
 class MediatingDisplayChanger;
+class PixelBuffer;
+class SessionContainer;
 class SessionEventSink;
 class SessionEventHandlerRegister;
-class BroadcastingSessionEventSink;
-}
-namespace time
-{
-class TimeSource;
-}
-namespace surfaces
-{
-class BufferStreamFactory;
+class SessionManager;
+class SnapshotStrategy;
+class SurfaceBuilder;
 class SurfaceStackModel;
 class SurfaceStack;
 class SurfaceController;
 class InputRegistrar;
-class SurfacesReport;
+class SceneReport;
 }
 namespace graphics
 {
@@ -186,40 +185,32 @@
      * configurable interfaces for modifying shell
      *  @{ */
     virtual std::shared_ptr<shell::SurfaceFactory>      the_shell_surface_factory();
-    virtual std::shared_ptr<shell::SessionContainer>    the_shell_session_container();
+    virtual std::shared_ptr<shell::SurfaceFactory>      the_scene_surface_factory();
     virtual std::shared_ptr<shell::FocusSetter>         the_shell_focus_setter();
-    virtual std::shared_ptr<shell::FocusSequence>       the_shell_focus_sequence();
     virtual std::shared_ptr<shell::PlacementStrategy>   the_shell_placement_strategy();
     virtual std::shared_ptr<shell::SessionListener>     the_shell_session_listener();
-    virtual std::shared_ptr<shell::PixelBuffer>         the_shell_pixel_buffer();
-    virtual std::shared_ptr<shell::SnapshotStrategy>    the_shell_snapshot_strategy();
     virtual std::shared_ptr<shell::DisplayLayout>       the_shell_display_layout();
     virtual std::shared_ptr<shell::SurfaceConfigurator> the_shell_surface_configurator();
-    virtual std::shared_ptr<shell::SessionEventSink>    the_shell_session_event_sink();
-    virtual std::shared_ptr<shell::SessionEventHandlerRegister> the_shell_session_event_handler_register();
     virtual std::shared_ptr<shell::SurfaceController>   the_shell_surface_controller();
     /** @} */
 
-    /** @name shell configuration - dependencies
-     * dependencies of shell on the rest of the Mir
-     *  @{ */
-    virtual std::shared_ptr<shell::SurfaceBuilder>     the_surface_builder();
-    virtual std::shared_ptr<surfaces::SurfaceController>     the_surface_controller();
-
-    /** @} */
-
-
-    /** @name surfaces configuration - customization
-     * configurable interfaces for modifying surfaces
-     *  @{ */
-    virtual std::shared_ptr<surfaces::SurfaceStackModel> the_surface_stack_model();
-    virtual std::shared_ptr<surfaces::SurfacesReport>    the_surfaces_report();
-    /** @} */
-
-    /** @name surfaces configuration - dependencies
-     * dependencies of surfaces on the rest of the Mir
-     *  @{ */
-    virtual std::shared_ptr<surfaces::BufferStreamFactory> the_buffer_stream_factory();
+    /** @name internal scene configuration
+     * builder functions used in the default implementation.
+     * The interfaces returned are not published, so the functions are only useful in tests
+     *  @{ */
+    virtual std::shared_ptr<scene::PixelBuffer>       the_pixel_buffer();
+    virtual std::shared_ptr<scene::SnapshotStrategy>  the_snapshot_strategy();
+    virtual std::shared_ptr<scene::SessionContainer>  the_session_container();
+    virtual std::shared_ptr<scene::SessionEventSink>  the_session_event_sink();
+    virtual std::shared_ptr<scene::SessionEventHandlerRegister> the_session_event_handler_register();
+    virtual std::shared_ptr<scene::SurfaceStackModel> the_surface_stack_model();
+    /** @} */
+
+    /** @name scene configuration - dependencies
+     * dependencies of scene on the rest of the Mir
+     *  @{ */
+    virtual std::shared_ptr<scene::BufferStreamFactory> the_buffer_stream_factory();
+    virtual std::shared_ptr<scene::SceneReport>      the_scene_report();
     /** @} */
 
 
@@ -227,7 +218,7 @@
      *  @{ */
     virtual std::shared_ptr<input::InputReport> the_input_report();
     virtual std::shared_ptr<input::CompositeEventFilter> the_composite_event_filter();
-    virtual std::shared_ptr<surfaces::InputRegistrar> the_input_registrar();
+    virtual std::shared_ptr<scene::InputRegistrar> the_input_registrar();
     virtual std::shared_ptr<shell::InputTargeter> the_input_targeter();
     virtual std::shared_ptr<input::CursorListener> the_cursor_listener();
     virtual std::shared_ptr<input::InputRegion>    the_input_region();
@@ -241,20 +232,15 @@
 
     virtual std::shared_ptr<time::TimeSource>    the_time_source();
 
-    virtual std::shared_ptr<shell::SessionManager> the_session_manager();
-
 protected:
     using DefaultConfigurationOptions::the_options;
     using DefaultConfigurationOptions::add_options;
     using DefaultConfigurationOptions::parse_options;
 
     virtual std::shared_ptr<input::InputChannelFactory> the_input_channel_factory();
-    virtual std::shared_ptr<shell::MediatingDisplayChanger> the_mediating_display_changer();
-    virtual std::shared_ptr<shell::BroadcastingSessionEventSink> the_broadcasting_session_event_sink();
+    virtual std::shared_ptr<scene::MediatingDisplayChanger> the_mediating_display_changer();
 
     CachedPtr<frontend::Connector>   connector;
-    CachedPtr<shell::SessionManager> session_manager;
-
 
     CachedPtr<input::InputConfiguration> input_configuration;
 
@@ -262,7 +248,7 @@
     CachedPtr<input::CompositeEventFilter> composite_event_filter;
     CachedPtr<input::InputManager>    input_manager;
     CachedPtr<input::InputRegion>     input_region;
-    CachedPtr<surfaces::InputRegistrar> input_registrar;
+    CachedPtr<scene::InputRegistrar> input_registrar;
     CachedPtr<shell::InputTargeter> input_targeter;
     CachedPtr<input::CursorListener> cursor_listener;
     CachedPtr<graphics::Platform>     graphics_platform;
@@ -279,17 +265,17 @@
     CachedPtr<frontend::SessionCreator>    session_creator;
     CachedPtr<compositor::RendererFactory> renderer_factory;
     CachedPtr<compositor::BufferStreamFactory> buffer_stream_factory;
-    CachedPtr<surfaces::SurfaceStack> surface_stack;
-    CachedPtr<surfaces::SurfacesReport> surfaces_report;
+    CachedPtr<scene::SurfaceStack> surface_stack;
+    CachedPtr<scene::SceneReport> scene_report;
 
     CachedPtr<shell::SurfaceFactory> shell_surface_factory;
-    CachedPtr<shell::SessionContainer>  shell_session_container;
+    CachedPtr<shell::SurfaceFactory> scene_surface_factory;
+    CachedPtr<scene::SessionContainer>  session_container;
     CachedPtr<shell::FocusSetter>       shell_focus_setter;
-    CachedPtr<shell::FocusSequence>     shell_focus_sequence;
     CachedPtr<shell::PlacementStrategy> shell_placement_strategy;
     CachedPtr<shell::SessionListener> shell_session_listener;
-    CachedPtr<shell::PixelBuffer>       shell_pixel_buffer;
-    CachedPtr<shell::SnapshotStrategy>  shell_snapshot_strategy;
+    CachedPtr<scene::PixelBuffer>       pixel_buffer;
+    CachedPtr<scene::SnapshotStrategy>  snapshot_strategy;
     CachedPtr<shell::DisplayLayout>     shell_display_layout;
     CachedPtr<shell::SurfaceConfigurator> shell_surface_configurator;
     CachedPtr<compositor::DisplayBufferCompositorFactory> display_buffer_compositor_factory;
@@ -297,26 +283,35 @@
     CachedPtr<compositor::Compositor> compositor;
     CachedPtr<logging::Logger> logger;
     CachedPtr<graphics::DisplayReport> display_report;
-    CachedPtr<surfaces::SurfaceController> surface_controller;
     CachedPtr<time::TimeSource> time_source;
     CachedPtr<MainLoop> main_loop;
     CachedPtr<ServerStatusListener> server_status_listener;
     CachedPtr<graphics::DisplayConfigurationPolicy> display_configuration_policy;
     CachedPtr<graphics::nested::HostConnection> host_connection;
-    CachedPtr<input::NestedInputRelay> nested_input_relay;
-    CachedPtr<shell::MediatingDisplayChanger> mediating_display_changer;
-    CachedPtr<shell::BroadcastingSessionEventSink> broadcasting_session_event_sink;
+    CachedPtr<scene::MediatingDisplayChanger> mediating_display_changer;
 
 private:
     std::shared_ptr<input::EventFilter> const default_filter;
-
     // the communications interface to use
     virtual std::shared_ptr<frontend::ProtobufIpcFactory> the_ipc_factory(
         std::shared_ptr<frontend::Shell> const& shell,
         std::shared_ptr<graphics::GraphicBufferAllocator> const& allocator);
 
     virtual std::string the_socket_file() const;
-    std::shared_ptr<input::NestedInputRelay> the_nested_input_relay();
+
+    // The following caches and factory functions are internal to the
+    // default implementations of corresponding the Mir components
+    CachedPtr<scene::BroadcastingSessionEventSink> broadcasting_session_event_sink;
+    CachedPtr<input::NestedInputRelay> nested_input_relay;
+    CachedPtr<scene::SurfaceController> surface_controller;
+    CachedPtr<scene::SessionManager> session_manager;
+
+    std::shared_ptr<scene::BroadcastingSessionEventSink> the_broadcasting_session_event_sink();
+    std::shared_ptr<input::NestedInputRelay>        the_nested_input_relay();
+    std::shared_ptr<scene::SessionManager>       the_session_manager();
+    std::shared_ptr<scene::SurfaceBuilder>       the_surface_builder();
+    std::shared_ptr<scene::SurfaceController>    the_surface_controller();
+    std::function<void()> force_threads_to_unblock_callback();
 };
 }
 

=== modified file 'include/server/mir/frontend/shell.h'
--- include/server/mir/frontend/shell.h	2013-08-28 03:41:48 +0000
+++ include/server/mir/frontend/shell.h	2013-11-25 03:07:43 +0000
@@ -36,7 +36,7 @@
 class Shell
 {
 public:
-    virtual ~Shell() {}
+    virtual ~Shell() = default;
 
     virtual std::shared_ptr<Session> open_session(
         std::string const& name, std::shared_ptr<EventSink> const& sink) = 0;
@@ -44,7 +44,7 @@
 
     virtual SurfaceId create_surface_for(std::shared_ptr<Session> const& session,
                                          shell::SurfaceCreationParameters const& params) = 0;
-    
+
     virtual void handle_surface_created(std::shared_ptr<Session> const& session) = 0;
 
 protected:

=== modified file 'include/server/mir/frontend/surface.h'
--- include/server/mir/frontend/surface.h	2013-10-15 08:53:10 +0000
+++ include/server/mir/frontend/surface.h	2013-11-25 03:07:43 +0000
@@ -25,6 +25,8 @@
 #include "mir/geometry/size.h"
 #include "mir_toolkit/common.h"
 
+#include <glm/glm.hpp>
+
 #include <memory>
 
 namespace mir
@@ -55,12 +57,7 @@
     virtual geometry::Size size() const = 0;
     virtual geometry::PixelFormat pixel_format() const = 0;
 
-    /// Submit the current client buffer, return the next client buffer
-    ///
-    /// \param [out] need_ipc:  True if the buffer content must be sent via IPC
-    ///                         False if only the buffer's ID must be sent.
-    /// \returns                The next client buffer
-    virtual std::shared_ptr<graphics::Buffer> advance_client_buffer(bool& need_full_ipc) = 0;
+    virtual std::shared_ptr<graphics::Buffer> advance_client_buffer() = 0;