Merge lp:~kdub/mir/n7-support into lp:mir/0.1

[Kevin DuBois]

graphics: android: support 'old aka 2012' nexus 7 hwc (nvidia tegra3 SoC) better.

graphics: android: support 'old aka 2012' nexus 7 hwc (nvidia tegra3 SoC) better.

improve hwc1.0 support to avert segfaulting on mir startup with hwc1.0 on tegra 3.
Mir demo clients seem to work well. Unity8 is still affected by lp:1238695

improve HWCLayerList class a bit as well. Before it was just made one layer on construction, now you can use an initializer list to have multiple layers.

These are hwc1.0 changes primarily, so I gave a basic sanity test to:
Galaxy Nexus (hwc1.0)
Nexus 7 (hwc1.0)
Nexus 4 (hwc1.1)

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:1219
http://jenkins.qa.ubuntu.com/job/mir-ci/1614/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-android-trusty-i386-build/163
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-clang-trusty-amd64-build/160
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-trusty-amd64-ci/12
        deb: http://jenkins.qa.ubuntu.com/job/mir-trusty-amd64-ci/12/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-trusty-armhf-ci/12
        deb: http://jenkins.qa.ubuntu.com/job/mir-trusty-armhf-ci/12/artifact/work/output/*zip*/output.zip

Click here to trigger a rebuild:
http://10.97.0.26:8080/job/mir-ci/1614/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-08 19:16:38 +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-08 19:16:38 +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-08 19:16:38 +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-08 19:16:38 +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-08 19:16:38 +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-08 19:16:38 +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-08 19:16:38 +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-08 19:16:38 +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-08 19:16:38 +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-08 19:16:38 +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-08 19:16:38 +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-08 19:16:38 +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-08 19:16:38 +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-08 19:16:38 +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-08 19:16:38 +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-08 19:16:38 +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-08 19:16:38 +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-08 19:16:38 +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-08 19:16:38 +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-10-21 07:47:44 +0000
+++ CMakeLists.txt	2013-11-08 19:16:38 +0000
@@ -28,7 +28,7 @@
 
 set(MIR_VERSION_MAJOR 0)
 set(MIR_VERSION_MINOR 1)
-set(MIR_VERSION_PATCH 0)
+set(MIR_VERSION_PATCH 1)
 
 set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} ${CMAKE_CURRENT_SOURCE_DIR}/cmake)
 

=== modified file 'debian/changelog'
--- debian/changelog	2013-11-05 09:36:37 +0000
+++ debian/changelog	2013-11-08 19:16:38 +0000
@@ -1,3 +1,9 @@
+mir (0.1.1-0ubuntu1) UNRELEASED; urgency=low
+
+  * Bump version to 0.1.1
+
+ -- Daniel van Vugt <[e-mail]>  Wed, 30 Oct 2013 11:46:13 +0800
+
 mir (0.1.0+14.04.20131030-0ubuntu1) trusty; urgency=low
 
   [ Ubuntu daily release ]
@@ -13,9 +19,6 @@
     server crashes without the timeout, rendering it needless anyway.
     (LP: #1245958)
 
-  [ Ubuntu daily release ]
-  * Automatic snapshot from revision 1163
-
  -- Ubuntu daily release <[e-mail]>  Wed, 30 Oct 2013 18:37:21 +0000
 
 mir (0.1.0+14.04.20131028-0ubuntu1) trusty; urgency=low
@@ -117,7 +120,7 @@
     #1244192)
 
   [ Ubuntu daily release ]
-  * Automatic snapshot from revision 1161
+  * Automatic snapshot from revision 1160
 
  -- Ubuntu daily release <[e-mail]>  Mon, 28 Oct 2013 02:04:31 +0000
 

=== modified file 'debian/control'
--- debian/control	2013-10-21 16:02:28 +0000
+++ debian/control	2013-11-08 19:16:38 +0000
@@ -69,7 +69,7 @@
  .
  Contains the protocol's definition files.
 
-Package: libmirserver9
+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: libmirserver9 (= ${binary:Version}),
+Depends: libmirserver11 (= ${binary:Version}),
          libmirprotobuf-dev (= ${binary:Version}),
          mircommon-dev (= ${binary:Version}),
          libglm-dev,

=== renamed file 'debian/libmirserver9.install' => 'debian/libmirserver11.install'
--- debian/libmirserver9.install	2013-10-21 17:49:01 +0000
+++ debian/libmirserver11.install	2013-11-08 19:16:38 +0000
@@ -1,1 +1,1 @@
-usr/lib/*/libmirserver.so.9
+usr/lib/*/libmirserver.so.11

=== modified file 'doc/Doxyfile.in'
--- doc/Doxyfile.in	2013-07-02 11:27:33 +0000
+++ doc/Doxyfile.in	2013-11-08 19:16:38 +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/building_source_for_android.md'
--- doc/building_source_for_android.md	2013-06-14 19:08:45 +0000
+++ doc/building_source_for_android.md	2013-11-08 19:16:38 +0000
@@ -52,17 +52,17 @@
 compile and run code, and is well suited for a development workflow.
 
 -  Be sure that the cross compiler that you are using matches the target
-   environment. (eg, make sure you're using the saucy toolchain if you're
-   targeting a saucy phablet image) You can specify the toolchain version
+   environment. (eg, make sure you're using the trusty toolchain if you're
+   targeting a trusty phablet image) You can specify the toolchain version
    thusly:
 
-        $ apt-get install g++-arm-linux-gnueabihf/saucy
+        $ apt-get install g++-arm-linux-gnueabihf/trusty
 
 -  Get access to armhf packages via apt-get. On an amd64/ia32 system, you can
    do this by adding a file like the one below to /etc/apt/sources.list.d/
 
         #example sources.list with armhf dependencies
-        deb [arch=armhf] http://ports.ubuntu.com/ubuntu-ports/ saucy main restricted universe multiverse
+        deb [arch=armhf] http://ports.ubuntu.com/ubuntu-ports/ trusty main restricted universe multiverse
     
     Then you should run:
 

=== modified file 'doc/component_reports.md'
--- doc/component_reports.md	2013-08-29 03:48:16 +0000
+++ doc/component_reports.md	2013-11-08 19:16:38 +0000
@@ -18,11 +18,13 @@
 
 Report                  | Handlers
 ----------------------- | --------
+connector-report        | log
 display-report          | log
 input-report            | log,lttng
 legacy-input-report     | log
 msg-processor-report    | log,lttng
 session-mediator-report | log
+surfaces-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
@@ -38,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-08-28 03:41:48 +0000
+++ doc/installing_prebuilt_on_pc.md	2013-11-08 19:16:38 +0000
@@ -1,8 +1,8 @@
 Installing pre-built packages on a PC {#installing_prebuilt_on_pc}
 =====================================
 
-Install saucy if you haven't done so already.  Uninstall any proprietary
-drivers (-nvidia, -fglrx) and reboot on the FOSS drivers.
+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:
 

=== modified file 'doc/using_mir_on_pc.md'
--- doc/using_mir_on_pc.md	2013-09-19 13:24:22 +0000
+++ doc/using_mir_on_pc.md	2013-11-08 19:16:38 +0000
@@ -15,19 +15,21 @@
     lsmod | grep drm
 
 Before you can use Mir you need to ensure you have the proper custom Mesa
-build installed. If you are running Ubuntu saucy
+build installed. If you are running Ubuntu 13.10 or later
 (see \ref installing_prebuilt_on_pc), you should be good to go.
 
 If you built Mir from source code (see \ref building_source_for_pc), you
 need to ensure you are using the proper Mesa at runtime. You can do that by
-installing the Mesa packages from saucy or by building the custom Mesa yourself
-and ensuring it can be found by Mir, e.g., by using LD_LIBRARY_PATH.
+installing the Mesa packages from Ubuntu 13.10 (or later) or by building the
+custom Mesa yourself and ensuring it can be found by Mir, e.g., by using
+LD_LIBRARY_PATH.
 
 Using Mir as system compositor with X
 -------------------------------------
 
 Note: for this to work you need to have Mir and all its dependencies (which
-include lightdm, Mesa and the Xorg drivers). The easiest way is to run saucy.
+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

=== modified file 'examples/demo-inprocess-surface-client/demo_inprocess_surface_client.cpp'
--- examples/demo-inprocess-surface-client/demo_inprocess_surface_client.cpp	2013-08-28 03:41:48 +0000
+++ examples/demo-inprocess-surface-client/demo_inprocess_surface_client.cpp	2013-11-08 19:16:38 +0000
@@ -49,7 +49,8 @@
     {
         client = std::make_shared<me::InprocessEGLClient>(
               config.the_graphics_platform(),
-              config.the_session_manager());
+              config.the_frontend_shell(),
+              config.the_focus_controller());
     });
     ///\internal [main_tag]
 

=== modified file 'examples/demo-inprocess-surface-client/inprocess_egl_client.cpp'
--- examples/demo-inprocess-surface-client/inprocess_egl_client.cpp	2013-09-19 13:24:22 +0000
+++ examples/demo-inprocess-surface-client/inprocess_egl_client.cpp	2013-11-08 19:16:38 +0000
@@ -20,11 +20,12 @@
 #include "example_egl_helper.h"
 
 #include "mir/main_loop.h"
-#include "mir/shell/session_manager.h"
-#include "mir/shell/surface.h"
+#include "mir/shell/focus_controller.h"
+#include "mir/frontend/surface.h"
 #include "mir/shell/surface_creation_parameters.h"
 #include "mir/shell/session.h"
 #include "mir/frontend/session.h"
+#include "mir/frontend/shell.h"
 #include "mir/geometry/size.h"
 #include "mir/graphics/buffer_properties.h"
 #include "mir/graphics/platform.h"
@@ -46,18 +47,19 @@
 #include <signal.h>
 
 namespace mf = mir::frontend;
-namespace mc = mir::compositor;
 namespace msh = mir::shell;
 namespace mg = mir::graphics;
 namespace me = mir::examples;
 namespace mircv = mir::input::receiver;
 namespace geom = mir::geometry;
 
-me::InprocessEGLClient::InprocessEGLClient(std::shared_ptr<mg::Platform> const& graphics_platform,
-                                           std::shared_ptr<msh::SessionManager> const& session_manager)
+me::InprocessEGLClient::InprocessEGLClient(
+    std::shared_ptr<mg::Platform> const& graphics_platform,
+    std::shared_ptr<frontend::Shell> const& shell,
+    std::shared_ptr<shell::FocusController> const& focus_controller)
   : graphics_platform(graphics_platform),
-
-    session_manager(session_manager),
+    shell(shell),
+    focus_controller(focus_controller),
     client_thread(std::mem_fn(&InprocessEGLClient::thread_loop), this),
     terminate(false)
 {
@@ -66,7 +68,7 @@
 me::InprocessEGLClient::~InprocessEGLClient()
 {
     terminate = true;
-    auto session = session_manager->focussed_application().lock();
+    auto session = focus_controller->focussed_application().lock();
     if (session)
         session->force_requests_to_complete();
     client_thread.join();
@@ -91,10 +93,9 @@
         .of_size(surface_size)
         .of_buffer_usage(mg::BufferUsage::hardware)
         .of_pixel_format(geom::PixelFormat::argb_8888);
-    auto session = session_manager->open_session("Inprocess client",
-                                                 std::make_shared<NullEventSink>());
+    auto session = shell->open_session("Inprocess client", std::make_shared<NullEventSink>());
     // TODO: Why do we get an ID? ~racarr
-    auto surface = session->get_surface(session_manager->create_surface_for(session, params));
+    auto surface = session->get_surface(shell->create_surface_for(session, params));
 
     auto input_platform = mircv::InputPlatform::create();
     input_thread = input_platform->create_input_thread(

=== modified file 'examples/demo-inprocess-surface-client/inprocess_egl_client.h'
--- examples/demo-inprocess-surface-client/inprocess_egl_client.h	2013-08-28 03:41:48 +0000
+++ examples/demo-inprocess-surface-client/inprocess_egl_client.h	2013-11-08 19:16:38 +0000
@@ -35,14 +35,9 @@
 class InputReceiverThread;
 }
 }
-namespace graphics
-{
-class Platform;
-}
-namespace shell
-{
-class SessionManager;
-}
+namespace graphics  { class Platform; }
+namespace shell     { class FocusController; }
+namespace frontend  { class Shell; }
 
 namespace examples
 {
@@ -51,8 +46,10 @@
 class InprocessEGLClient
 {
 public:
-    InprocessEGLClient(std::shared_ptr<graphics::Platform> const& graphics_platform,
-                       std::shared_ptr<shell::SessionManager> const& session_manager);
+    InprocessEGLClient(
+        std::shared_ptr<graphics::Platform> const& graphics_platform,
+        std::shared_ptr<frontend::Shell> const& shell,
+        std::shared_ptr<shell::FocusController> const& focus_controller);
 
     ~InprocessEGLClient();
 
@@ -62,7 +59,8 @@
 
 private:
     std::shared_ptr<graphics::Platform> const graphics_platform;
-    std::shared_ptr<shell::SessionManager> const session_manager;
+    std::shared_ptr<frontend::Shell> const shell;
+    std::shared_ptr<shell::FocusController> const focus_controller;
 
     std::thread client_thread;
     

=== modified file 'examples/demo-shell/demo_shell.cpp'
--- examples/demo-shell/demo_shell.cpp	2013-09-17 18:40:01 +0000
+++ examples/demo-shell/demo_shell.cpp	2013-11-08 19:16:38 +0000
@@ -24,11 +24,7 @@
 
 #include "mir/run_mir.h"
 #include "mir/report_exception.h"
-#include "mir/shell/session_manager.h"
-#include "mir/shell/registration_order_focus_sequence.h"
-#include "mir/shell/default_focus_mechanism.h"
 #include "mir/shell/session_container.h"
-#include "mir/shell/organising_surface_factory.h"
 #include "mir/graphics/display.h"
 #include "mir/input/composite_event_filter.h"
 
@@ -97,7 +93,6 @@
             // We use this strange two stage initialization to avoid a circular dependency between the EventFilters
             // and the SessionStore
             wm->set_focus_controller(config.the_focus_controller());
-            wm->set_session_manager(config.the_session_manager());
             wm->set_display(config.the_display());
             wm->set_compositor(config.the_compositor());
         });

=== modified file 'examples/demo-shell/window_manager.cpp'
--- examples/demo-shell/window_manager.cpp	2013-09-17 19:46:15 +0000
+++ examples/demo-shell/window_manager.cpp	2013-11-08 19:16:38 +0000
@@ -19,7 +19,6 @@
 #include "window_manager.h"
 
 #include "mir/shell/focus_controller.h"
-#include "mir/shell/session_manager.h"
 #include "mir/shell/session.h"
 #include "mir/shell/surface.h"
 #include "mir/graphics/display.h"
@@ -51,12 +50,6 @@
     focus_controller = controller;
 }
 
-void me::WindowManager::set_session_manager(
-    std::shared_ptr<msh::SessionManager> const& sm)
-{
-    session_manager = sm;
-}
-
 void me::WindowManager::set_display(std::shared_ptr<mg::Display> const& dpy)
 {
     display = dpy;
@@ -130,7 +123,7 @@
         }
     }
     else if (event.type == mir_event_type_motion &&
-             session_manager)
+             focus_controller)
     {
         geometry::Point cursor = average_pointer(event.motion);
 
@@ -138,7 +131,7 @@
         MirMotionAction action = static_cast<MirMotionAction>(event.motion.action & ~0xff00);
 
         std::shared_ptr<msh::Session> app =
-            session_manager->focussed_application().lock();
+            focus_controller->focussed_application().lock();
 
         int fingers = static_cast<int>(event.motion.pointer_count);
 

=== modified file 'examples/demo-shell/window_manager.h'
--- examples/demo-shell/window_manager.h	2013-09-17 18:40:01 +0000
+++ examples/demo-shell/window_manager.h	2013-11-08 19:16:38 +0000
@@ -29,7 +29,6 @@
 namespace shell
 {
 class FocusController;
-class SessionManager;
 }
 namespace graphics
 {
@@ -49,7 +48,6 @@
     ~WindowManager() = default;
 
     void set_focus_controller(std::shared_ptr<shell::FocusController> const& focus_controller);
-    void set_session_manager(std::shared_ptr<shell::SessionManager> const& sm);
     void set_display(std::shared_ptr<graphics::Display> const& display);
     void set_compositor(std::shared_ptr<compositor::Compositor> const& compositor);
     
@@ -61,7 +59,6 @@
 
 private:
     std::shared_ptr<shell::FocusController> focus_controller;
-    std::shared_ptr<shell::SessionManager> session_manager;
     std::shared_ptr<graphics::Display> display;
     std::shared_ptr<compositor::Compositor> compositor;
 

=== 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-08 19:16:38 +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/image_renderer.cpp'
--- examples/image_renderer.cpp	2013-03-21 03:32:59 +0000
+++ examples/image_renderer.cpp	2013-11-08 19:16:38 +0000
@@ -87,11 +87,68 @@
     BOOST_THROW_EXCEPTION(std::runtime_error(object_info_err));
 }
 
+class GLState
+{
+public:
+    GLState(GLint attrib_loc)
+        : attrib_loc{attrib_loc}
+    {
+        glGetIntegerv(GL_CURRENT_PROGRAM, &program);
+        glGetIntegerv(GL_TEXTURE_BINDING_2D, &texture);
+        glGetIntegerv(GL_ARRAY_BUFFER_BINDING, &buffer);
+        glGetIntegerv(GL_ACTIVE_TEXTURE, &active_texture_unit);
+        if (attrib_loc >= 0)
+        {
+            glGetVertexAttribiv(attrib_loc, GL_VERTEX_ATTRIB_ARRAY_ENABLED, &attrib_enabled);
+            glGetVertexAttribiv(attrib_loc, GL_VERTEX_ATTRIB_ARRAY_SIZE, &attrib_size);
+            glGetVertexAttribiv(attrib_loc, GL_VERTEX_ATTRIB_ARRAY_TYPE, &attrib_type);
+            glGetVertexAttribiv(attrib_loc, GL_VERTEX_ATTRIB_ARRAY_NORMALIZED, &attrib_normalized);
+            glGetVertexAttribiv(attrib_loc, GL_VERTEX_ATTRIB_ARRAY_STRIDE, &attrib_stride);
+            glGetVertexAttribPointerv(attrib_loc, GL_VERTEX_ATTRIB_ARRAY_POINTER, &attrib_pointer);
+        }
+    }
+
+    GLState() : GLState{invalid_attrib_loc} {}
+
+    ~GLState()
+    {
+        glUseProgram(program);
+        glBindTexture(GL_TEXTURE_2D, texture);
+        glBindBuffer(GL_ARRAY_BUFFER, buffer);
+        glActiveTexture(active_texture_unit);
+        if (attrib_loc >= 0)
+        {
+            glVertexAttribPointer(attrib_loc, attrib_size, attrib_type,
+                                  attrib_normalized, attrib_stride, attrib_pointer);
+            if (attrib_enabled)
+                glEnableVertexAttribArray(attrib_loc);
+            else
+                glDisableVertexAttribArray(attrib_loc);
+        }
+    }
+
+private:
+    static GLint const invalid_attrib_loc = -1;
+    GLint program = 0;
+    GLint texture = 0;
+    GLint buffer = 0;
+    GLint active_texture_unit = 0;
+    GLint attrib_loc = invalid_attrib_loc;
+    GLint attrib_enabled = 0;
+    GLint attrib_size = 0;
+    GLint attrib_type = 0;
+    GLint attrib_normalized = 0;
+    GLint attrib_stride = 0;
+    GLvoid* attrib_pointer = nullptr;
+};
+
 }
 
 mt::ImageRenderer::ImageRenderer(const uint8_t* pixel_data, mir::geometry::Size size,
                                  uint32_t bytes_per_pixel)
 {
+    GLState gl_state;
+
     resources.setup();
 
     /* Upload the texture */
@@ -173,7 +230,6 @@
     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
 
     glUniform1i(tex_loc, 0);
-    glBindTexture(GL_TEXTURE_2D, 0);
 
     /* Create VBO */
     glGenBuffers(1, &vertex_attribs_vbo);
@@ -181,14 +237,13 @@
     glBindBuffer(GL_ARRAY_BUFFER, vertex_attribs_vbo);
     glBufferData(GL_ARRAY_BUFFER, sizeof(vertex_attribs),
                  glm::value_ptr(vertex_attribs[0]), GL_STATIC_DRAW);
-
-    glBindBuffer(GL_ARRAY_BUFFER, 0);
-    glUseProgram(0);
 }
 
 
 void mt::ImageRenderer::render()
 {
+    GLState gl_state(resources.position_attr_loc);
+
     glUseProgram(resources.program);
 
     glActiveTexture(GL_TEXTURE0);
@@ -202,5 +257,4 @@
     /* Draw */
     glEnableVertexAttribArray(resources.position_attr_loc);
     glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
-    glDisableVertexAttribArray(resources.position_attr_loc);
 }

=== modified file 'examples/render_surfaces.cpp'
--- examples/render_surfaces.cpp	2013-10-15 08:53:10 +0000
+++ examples/render_surfaces.cpp	2013-11-08 19:16:38 +0000
@@ -16,7 +16,7 @@
  * Authored by: Alexandros Frantzis <[e-mail]>
  */
 
-#include "mir/compositor/default_display_buffer_compositor_factory.h"
+#include "mir/compositor/display_buffer_compositor_factory.h"
 #include "mir/compositor/display_buffer_compositor.h"
 #include "mir/graphics/graphic_buffer_allocator.h"
 #include "mir/frontend/connector.h"
@@ -28,7 +28,9 @@
 #include "mir/graphics/display.h"
 #include "mir/graphics/display_buffer.h"
 #include "mir/shell/surface_builder.h"
-#include "mir/surfaces/surface.h"
+// Just the following three functions stop render_surfaces.cpp using shell::Surface
+//    flag_for_render(), set_rotation() and set_alpha()
+#include "mir/surfaces/basic_surface.h"
 #include "mir/run_mir.h"
 #include "mir/report_exception.h"
 
@@ -55,6 +57,7 @@
 namespace mi = mir::input;
 namespace geom = mir::geometry;
 namespace mt = mir::tools;
+namespace me = mir::examples;
 
 ///\page render_surfaces-example render_surfaces.cpp: A simple program using the mir library.
 ///\tableofcontents
@@ -184,7 +187,7 @@
 {
 public:
     Moveable() {}
-    Moveable(ms::Surface& s, const geom::Size& display_size,
+    Moveable(ms::BasicSurface& 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())},
@@ -232,7 +235,7 @@
     }
 
 private:
-    ms::Surface* surface;
+    ms::BasicSurface* surface;
     geom::Size display_size;
     float x;
     float y;
@@ -248,7 +251,7 @@
 
 ///\internal [RenderSurfacesServerConfiguration_tag]
 // Extend the default configuration to manage moveables.
-class RenderSurfacesServerConfiguration : public mir::examples::ServerConfiguration
+class RenderSurfacesServerConfiguration : public me::ServerConfiguration
 {
 public:
     RenderSurfacesServerConfiguration(int argc, char const** argv)
@@ -349,32 +352,32 @@
             uint32_t frames;
         };
 
-        class RenderSurfacesDisplayBufferCompositorFactory : public mc::DefaultDisplayBufferCompositorFactory
+        class RenderSurfacesDisplayBufferCompositorFactory : public mc::DisplayBufferCompositorFactory
         {
         public:
             RenderSurfacesDisplayBufferCompositorFactory(
-                std::shared_ptr<mc::Scene> const& scene,
-                std::shared_ptr<mc::RendererFactory> const& renderer_factory,
-                std::shared_ptr<mc::OverlayRenderer> const& overlay_renderer,
+                std::shared_ptr<mc::DisplayBufferCompositorFactory> const& factory,
                 std::vector<Moveable>& moveables)
-                : DefaultDisplayBufferCompositorFactory{scene, renderer_factory, overlay_renderer},
+                : factory{factory},
                   moveables(moveables)
             {
             }
 
             std::unique_ptr<mc::DisplayBufferCompositor> create_compositor_for(mg::DisplayBuffer& display_buffer)
             {
-                auto cs = DefaultDisplayBufferCompositorFactory::create_compositor_for(display_buffer);
-                auto raw = new RenderSurfacesDisplayBufferCompositor(std::move(cs), moveables);
+                auto compositor = factory->create_compositor_for(display_buffer);
+                auto raw = new RenderSurfacesDisplayBufferCompositor(
+                    std::move(compositor), moveables);
                 return std::unique_ptr<RenderSurfacesDisplayBufferCompositor>(raw);
             }
+
+        private:
+            std::shared_ptr<mc::DisplayBufferCompositorFactory> const factory;
             std::vector<Moveable>& moveables;
         };
 
         return std::make_shared<RenderSurfacesDisplayBufferCompositorFactory>(
-            the_scene(),
-            the_renderer_factory(),
-            the_overlay_renderer(),
+            me::ServerConfiguration::the_display_buffer_compositor_factory(),
             moveables);
     }
     ///\internal [RenderSurfacesDisplayBufferCompositor_tag]
@@ -405,7 +408,7 @@
         int i = 0;
         for (auto& m : moveables)
         {
-            std::shared_ptr<ms::Surface> s = surface_builder->create_surface(
+            std::shared_ptr<ms::BasicSurface> s = surface_builder->create_surface(
                     nullptr,
                     msh::a_surface().of_size(surface_size)
                                    .of_pixel_format(surface_pf)

=== modified file 'examples/render_to_fb.cpp'
--- examples/render_to_fb.cpp	2013-09-19 13:24:22 +0000
+++ examples/render_to_fb.cpp	2013-11-08 19:16:38 +0000
@@ -21,8 +21,6 @@
 #include "mir/default_server_configuration.h"
 #include "mir/graphics/display.h"
 #include "mir/graphics/display_buffer.h"
-#include "mir/graphics/default_display_configuration_policy.h"
-#include "mir/graphics/platform.h"
 #include "mir/report_exception.h"
 
 #include <csignal>
@@ -56,8 +54,7 @@
 
     mir::DefaultServerConfiguration conf{argc, argv};
 
-    auto platform = conf.the_graphics_platform();
-    auto display = platform->create_display(std::make_shared<mg::DefaultDisplayConfigurationPolicy>());
+    auto display = conf.the_display();
 
     mir::draw::glAnimationBasic gl_animation;
 

=== modified file 'include/client/mir_toolkit/mir_client_library_drm.h'
--- include/client/mir_toolkit/mir_client_library_drm.h	2013-05-30 03:50:54 +0000
+++ include/client/mir_toolkit/mir_client_library_drm.h	2013-11-08 19:16:38 +0000
@@ -27,6 +27,8 @@
 extern "C" {
 #endif
 
+struct gbm_device;
+
 typedef void (*mir_drm_auth_magic_callback)(int status, void *context);
 
 /* Authenticates a DRM magic cookie */
@@ -35,6 +37,18 @@
                                              mir_drm_auth_magic_callback callback,
                                              void *context);
 
+/**
+ * Set the gbm_device to be used by the EGL implementation.
+ * This is required if the application needs to create EGLImages from
+ * gbm buffers objects created on that gbm device.
+ * \param [in] connection  The connection
+ * \param [in] dev         The gbm_device to set
+ * \return                 A non-zero value if the operation was successful,
+ *                         0 otherwise
+ */
+int mir_connection_drm_set_gbm_device(MirConnection* connection,
+                                      struct gbm_device* dev);
+
 #ifdef __cplusplus
 }
 /**@}*/

=== modified file 'include/platform/mir/graphics/nested_context.h'
--- include/platform/mir/graphics/nested_context.h	2013-10-23 09:33:59 +0000
+++ include/platform/mir/graphics/nested_context.h	2013-11-08 19:16:38 +0000
@@ -21,6 +21,8 @@
 
 #include <vector>
 
+struct gbm_device;
+
 namespace mir
 {
 namespace graphics
@@ -33,6 +35,7 @@
 
     virtual std::vector<int> platform_fd_items() = 0;
     virtual void drm_auth_magic(int magic) = 0;
+    virtual void drm_set_gbm_device(struct gbm_device* dev) = 0;
 
 protected:
     NestedContext() = default;

=== renamed file 'include/server/mir/surfaces/buffer_stream.h' => 'include/server/mir/compositor/buffer_stream.h'
--- include/server/mir/surfaces/buffer_stream.h	2013-08-28 03:41:48 +0000
+++ include/server/mir/compositor/buffer_stream.h	2013-11-08 19:16:38 +0000
@@ -17,8 +17,8 @@
  * Kevin DuBois <[e-mail]>
  */
 
-#ifndef MIR_SURFACES_BUFFER_STREAM_H_
-#define MIR_SURFACES_BUFFER_STREAM_H_
+#ifndef MIR_COMPOSITOR_BUFFER_STREAM_H_
+#define MIR_COMPOSITOR_BUFFER_STREAM_H_
 
 #include "mir/geometry/size.h"
 #include "mir/geometry/pixel_format.h"
@@ -33,13 +33,13 @@
 class Buffer;
 }
 
-namespace surfaces
+namespace compositor
 {
 
 class BufferStream
 {
 public:
-    virtual ~BufferStream() {/* TODO: make nothrow */}
+    virtual ~BufferStream() = default;
 
     virtual std::shared_ptr<graphics::Buffer> secure_client_buffer() = 0;
     virtual std::shared_ptr<graphics::Buffer>
@@ -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;
 };
@@ -54,4 +55,4 @@
 }
 }
 
-#endif /* MIR_SURFACES_BUFFER_STREAM_H_ */
+#endif /* MIR_COMPOSITOR_BUFFER_STREAM_H_ */

=== modified file 'include/server/mir/compositor/scene.h'
--- include/server/mir/compositor/scene.h	2013-10-16 07:57:33 +0000
+++ include/server/mir/compositor/scene.h	2013-11-08 19:16:38 +0000
@@ -26,12 +26,9 @@
 
 namespace mir
 {
-namespace surfaces
+namespace compositor
 {
 class BufferStream;
-}
-namespace compositor
-{
 class CompositingCriteria;
 
 class FilterForScene
@@ -52,7 +49,7 @@
 public:
     virtual ~OperatorForScene() {}
 
-    virtual void operator()(CompositingCriteria const&, surfaces::BufferStream&) = 0;
+    virtual void operator()(CompositingCriteria const&, BufferStream&) = 0;
 
 protected:
     OperatorForScene() = default;
@@ -78,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-10-23 09:02:02 +0000
+++ include/server/mir/default_configuration_options.h	2013-11-08 19:16:38 +0000
@@ -35,10 +35,12 @@
     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 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 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-05 09:36:37 +0000
+++ include/server/mir/default_server_configuration.h	2013-11-08 19:16:38 +0000
@@ -85,6 +85,7 @@
 class SurfaceStack;
 class SurfaceController;
 class InputRegistrar;
+class SurfacesReport;
 }
 namespace graphics
 {
@@ -105,6 +106,7 @@
 class CursorListener;
 class InputRegion;
 class NestedInputRelay;
+class EventHandler;
 }
 
 namespace logging
@@ -138,7 +140,7 @@
     virtual std::shared_ptr<compositor::RendererFactory>   the_renderer_factory();
     virtual std::shared_ptr<graphics::DisplayConfigurationPolicy> the_display_configuration_policy();
     virtual std::shared_ptr<graphics::nested::HostConnection> the_host_connection();
-    virtual std::shared_ptr<input::NestedInputRelay> the_nested_input_relay();
+    virtual std::shared_ptr<input::EventFilter> the_nested_event_filter();
     /** @} */
 
     /** @name graphics configuration - dependencies
@@ -184,6 +186,7 @@
      * configurable interfaces for modifying shell
      *  @{ */
     virtual std::shared_ptr<shell::SurfaceFactory>      the_shell_surface_factory();
+    virtual std::shared_ptr<shell::SurfaceFactory>      the_surfaces_surface_factory();
     virtual std::shared_ptr<shell::SessionContainer>    the_shell_session_container();
     virtual std::shared_ptr<shell::FocusSetter>         the_shell_focus_setter();
     virtual std::shared_ptr<shell::FocusSequence>       the_shell_focus_sequence();
@@ -195,6 +198,7 @@
     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
@@ -210,6 +214,7 @@
      * 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
@@ -276,7 +281,10 @@
     CachedPtr<compositor::RendererFactory> renderer_factory;
     CachedPtr<compositor::BufferStreamFactory> buffer_stream_factory;
     CachedPtr<surfaces::SurfaceStack> surface_stack;
+    CachedPtr<surfaces::SurfacesReport> surfaces_report;
+
     CachedPtr<shell::SurfaceFactory> shell_surface_factory;
+    CachedPtr<shell::SurfaceFactory> surfaces_surface_factory;
     CachedPtr<shell::SessionContainer>  shell_session_container;
     CachedPtr<shell::FocusSetter>       shell_focus_setter;
     CachedPtr<shell::FocusSequence>     shell_focus_sequence;
@@ -310,6 +318,7 @@
         std::shared_ptr<graphics::GraphicBufferAllocator> const& allocator);
 
     virtual std::string the_socket_file() const;
+    std::shared_ptr<input::NestedInputRelay> the_nested_input_relay();
 };
 }
 

=== 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-08 19:16:38 +0000
@@ -55,12 +55,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;
 
     virtual bool supports_input() const = 0;
     virtual int client_input_fd() const = 0;
@@ -75,21 +70,7 @@
 
 auto as_internal_surface(std::shared_ptr<Surface> const& surface)
     -> std::shared_ptr<graphics::InternalSurface>;
-
-class ClientTrackingSurface : public Surface
-{
-public:
-    ClientTrackingSurface();
-    virtual ~ClientTrackingSurface() = default;
-    
-    virtual std::shared_ptr<graphics::Buffer> advance_client_buffer(bool& need_full_ipc) override;
-
-    virtual std::shared_ptr<graphics::Buffer> advance_client_buffer() = 0;
-private:
-    std::shared_ptr<ClientBufferTracker> client_tracker;
-};
-
-}   
+}
 }
 
 

=== removed directory 'include/server/mir/graphics/nested'
=== modified file 'include/server/mir/shell/application_session.h'
--- include/server/mir/shell/application_session.h	2013-08-28 03:41:48 +0000
+++ include/server/mir/shell/application_session.h	2013-11-08 19:16:38 +0000
@@ -36,6 +36,9 @@
 class SnapshotStrategy;
 class SessionListener;
 
+// TODO make private to shell
+// This first needs unity-mir and unit-system_compositor to be updated to use Session
+// and that first needs -c 1167 of development-branch to land on lp:mir
 class ApplicationSession : public Session
 {
 public:

=== modified file 'include/server/mir/shell/focus_controller.h'
--- include/server/mir/shell/focus_controller.h	2013-08-28 03:41:48 +0000
+++ include/server/mir/shell/focus_controller.h	2013-11-08 19:16:38 +0000
@@ -19,18 +19,22 @@
 #ifndef MIR_SHELL_FOCUS_CONTROLLER_H_
 #define MIR_SHELL_FOCUS_CONTROLLER_H_
 
+#include <memory>
+
 namespace mir
 {
-
 namespace shell
 {
+class Session;
 
 class FocusController
 {
 public:
-    virtual ~FocusController() {}
+    virtual ~FocusController() = default;
 
     virtual void focus_next() = 0;
+    virtual std::weak_ptr<Session> focussed_application() const = 0;
+    virtual void set_focus_to(std::shared_ptr<Session> const& focus) = 0;
 
 protected:
     FocusController() = default;

=== modified file 'include/server/mir/shell/session.h'
--- include/server/mir/shell/session.h	2013-08-28 03:41:48 +0000
+++ include/server/mir/shell/session.h	2013-11-08 19:16:38 +0000
@@ -37,6 +37,7 @@
 
     virtual void take_snapshot(SnapshotCallback const& snapshot_taken) = 0;
     virtual std::shared_ptr<Surface> default_surface() const = 0;
+    virtual void set_lifecycle_state(MirLifecycleState state) = 0;
 };
 
 }

=== modified file 'include/server/mir/shell/session_manager.h'
--- include/server/mir/shell/session_manager.h	2013-08-28 03:41:48 +0000
+++ include/server/mir/shell/session_manager.h	2013-11-08 19:16:38 +0000
@@ -48,6 +48,9 @@
 class SessionListener;
 struct SurfaceCreationParameters;
 
+// TODO make private to shell
+// This first needs unity-mir to be updated to use FocusController
+// and that first needs -c 1175 of development-branch to land on lp:mir
 class SessionManager : public frontend::Shell, public shell::FocusController
 {
 public:

=== modified file 'include/server/mir/shell/surface.h'
--- include/server/mir/shell/surface.h	2013-10-15 08:53:10 +0000
+++ include/server/mir/shell/surface.h	2013-11-08 19:16:38 +0000
@@ -21,87 +21,35 @@
 #define MIR_SHELL_SURFACE_H_
 
 #include "mir/shell/surface_buffer_access.h"
+#include "mir/geometry/rectangle.h"
 #include "mir/frontend/surface.h"
-#include "mir/frontend/surface_id.h"
-#include "mir/surfaces/surface.h"
-
-#include "mir_toolkit/common.h"
 
 #include <string>
+#include <vector>
 
 namespace mir
 {
-namespace frontend
-{
-class EventSink;
-}
 namespace shell
 {
 class InputTargeter;
-class Session;
-class SurfaceBuilder;
-class SurfaceConfigurator;
 class SurfaceController;
-struct SurfaceCreationParameters;
 
-class Surface : public frontend::ClientTrackingSurface, public shell::SurfaceBufferAccess
+class Surface : public frontend::Surface, public shell::SurfaceBufferAccess
 {
 public:
-    Surface(
-        Session* session,
-        std::shared_ptr<SurfaceBuilder> const& builder,
-        std::shared_ptr<SurfaceConfigurator> const& configurator,
-        SurfaceCreationParameters const& params,
-        frontend::SurfaceId id,
-        std::shared_ptr<frontend::EventSink> const& event_sink);
-
-    ~Surface() noexcept;
-
-    virtual void hide();
-    virtual void show();
-
-    virtual void force_requests_to_complete();
-
-    virtual std::string name() const;
-
-    virtual void move_to(geometry::Point const& top_left);
-
-    virtual geometry::Size size() const;
-    virtual geometry::Point top_left() const;
-
-    virtual geometry::PixelFormat pixel_format() const;
-
-    virtual void with_most_recent_buffer_do(
-        std::function<void(graphics::Buffer&)> const& exec);
-    virtual std::shared_ptr<graphics::Buffer> advance_client_buffer();
-
-    virtual bool supports_input() const;
-    virtual int client_input_fd() const;
-
-    virtual int configure(MirSurfaceAttrib attrib, int value);
-    virtual MirSurfaceType type() const;
-    virtual MirSurfaceState state() const;
-
-    virtual void take_input_focus(std::shared_ptr<InputTargeter> const& targeter);
-    virtual void set_input_region(std::vector<geometry::Rectangle> const& region);
-
-    virtual void allow_framedropping(bool); 
-    
-    virtual void raise(std::shared_ptr<SurfaceController> const& controller);
-private:
-    bool set_type(MirSurfaceType t);  // Use configure() to make public changes
-    bool set_state(MirSurfaceState s);
-    void notify_change(MirSurfaceAttrib attrib, int value);
-
-    std::shared_ptr<SurfaceBuilder> const builder;
-    std::shared_ptr<SurfaceConfigurator> const configurator;
-    std::shared_ptr<mir::surfaces::Surface> const surface;
-
-    frontend::SurfaceId const id;
-    std::shared_ptr<frontend::EventSink> const event_sink;
-
-    MirSurfaceType type_value;
-    MirSurfaceState state_value;
+    virtual void hide() = 0;
+    virtual void show() = 0;
+    virtual void move_to(geometry::Point const& top_left) = 0;
+    virtual geometry::Point top_left() const = 0;
+
+    virtual void take_input_focus(std::shared_ptr<InputTargeter> const& targeter) = 0;
+    virtual void set_input_region(std::vector<geometry::Rectangle> const& region) = 0;
+
+    virtual void allow_framedropping(bool) = 0;
+
+    virtual void raise(std::shared_ptr<SurfaceController> const& controller) = 0;
+
+    virtual void resize(geometry::Size const& size) = 0;
 };
 }
 }

=== modified file 'include/server/mir/shell/surface_builder.h'
--- include/server/mir/shell/surface_builder.h	2013-08-28 03:41:48 +0000
+++ include/server/mir/shell/surface_builder.h	2013-11-08 19:16:38 +0000
@@ -24,7 +24,7 @@
 
 namespace mir
 {
-namespace surfaces { class Surface; }
+namespace surfaces { class BasicSurface; }
 
 namespace shell
 {
@@ -34,9 +34,9 @@
 class SurfaceBuilder
 {
 public:
-    virtual std::weak_ptr<surfaces::Surface> create_surface(Session* session, SurfaceCreationParameters const& params) = 0;
+    virtual std::weak_ptr<surfaces::BasicSurface> create_surface(Session* session, SurfaceCreationParameters const& params) = 0;
 
-    virtual void destroy_surface(std::weak_ptr<surfaces::Surface> const& surface) = 0;
+    virtual void destroy_surface(std::weak_ptr<surfaces::BasicSurface> const& surface) = 0;
 protected:
     SurfaceBuilder() = default;
     virtual ~SurfaceBuilder() {} // should be "= default;" but that causes "noexcept" spread

=== modified file 'include/server/mir/shell/surface_controller.h'
--- include/server/mir/shell/surface_controller.h	2013-07-29 23:14:57 +0000
+++ include/server/mir/shell/surface_controller.h	2013-11-08 19:16:38 +0000
@@ -26,7 +26,7 @@
 {
 namespace surfaces 
 {
-class Surface;
+class BasicSurface;
 }
 
 namespace shell
@@ -35,7 +35,7 @@
 class SurfaceController
 {
 public:
-    virtual void raise(std::weak_ptr<surfaces::Surface> const& surface) = 0;
+    virtual void raise(std::weak_ptr<surfaces::BasicSurface> const& surface) = 0;
 
 protected:
     SurfaceController() = default;

=== renamed file 'include/server/mir/surfaces/surface.h' => 'include/server/mir/surfaces/basic_surface.h'
--- include/server/mir/surfaces/surface.h	2013-08-29 09:20:06 +0000
+++ include/server/mir/surfaces/basic_surface.h	2013-11-08 19:16:38 +0000
@@ -16,8 +16,8 @@
  * Authored by: Thomas Voss <[e-mail]>
  */
 
-#ifndef MIR_SURFACES_SURFACE_H_
-#define MIR_SURFACES_SURFACE_H_
+#ifndef MIR_SURFACES_BASIC_SURFACE_H_
+#define MIR_SURFACES_BASIC_SURFACE_H_
 
 #include "mir/geometry/pixel_format.h"
 #include "mir/geometry/rectangle.h"
@@ -34,6 +34,7 @@
 {
 class CompositingCriteria;
 struct BufferIPCPackage;
+class BufferStream;
 }
 namespace graphics
 {
@@ -46,57 +47,48 @@
 }
 namespace surfaces
 {
-class SurfaceState;
-class BufferStream;
-
-// TODO this is ideally an implementation class. It is only in a public header
-// TODO because it is used in some example code (which probably needs rethinking).
-class Surface
+class BasicSurface
 {
 public:
-    Surface(std::shared_ptr<surfaces::SurfaceState> const& surface_state,
-            std::shared_ptr<BufferStream> const& buffer_stream,
-            std::shared_ptr<input::InputChannel> const& input_channel);
-
-    ~Surface();
-
-    std::string const& name() const;
-    void move_to(geometry::Point const& top_left);
-    void set_rotation(float degrees, glm::vec3 const& axis);
-    void set_alpha(float alpha);
-    void set_hidden(bool is_hidden);
-
-    /* From Renderable */
-    geometry::Point top_left() const;
-    geometry::Size size() const;
-
-    geometry::PixelFormat pixel_format() const;
-
-    std::shared_ptr<graphics::Buffer> snapshot_buffer() const;
-    std::shared_ptr<graphics::Buffer> advance_client_buffer();
-    void force_requests_to_complete();
-    void flag_for_render();
-
-    bool supports_input() const;
-    int client_input_fd() const;
-    void allow_framedropping(bool);
-    std::shared_ptr<input::InputChannel> input_channel() const;
-
-    void set_input_region(std::vector<geometry::Rectangle> const& input_rectangles);
-
-    std::shared_ptr<compositor::CompositingCriteria> compositing_criteria();
-
-    std::shared_ptr<BufferStream> buffer_stream() const;
-
-    std::shared_ptr<input::Surface> input_surface() const;
+    BasicSurface() = default;
+    virtual ~BasicSurface() = default;
+
+    virtual std::string const& name() const = 0;
+    virtual void move_to(geometry::Point const& top_left) = 0;
+    virtual void set_rotation(float degrees, glm::vec3 const& axis) = 0;
+    virtual void set_alpha(float alpha) = 0;
+    virtual void set_hidden(bool is_hidden) = 0;
+
+    virtual geometry::Point top_left() const = 0;
+    virtual geometry::Size size() const = 0;
+
+    virtual geometry::PixelFormat pixel_format() const = 0;
+
+    virtual std::shared_ptr<graphics::Buffer> snapshot_buffer() const = 0;