Merge lp:~robertcarr/mir/delete-some-test-code into lp:mir/0.1

[Robert Carr]

Avoid defining useless test structs in acceptance tests.

Factor out a bunch of "ClientConfigCommon".

=== 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-07 18:01:18 +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-07 18:01:18 +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-07 18:01:18 +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-07 18:01:18 +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-07 18:01:18 +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-07 18:01:18 +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-07 18:01:18 +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-07 18:01:18 +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-07 18:01:18 +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-07 18:01:18 +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/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-07 18:01:18 +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-07 18:01:18 +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-07 18:01:18 +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-07 18:01:18 +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-07 18:01:18 +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-07 18:01:18 +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-07 18:01:18 +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-07 18:01:18 +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-07 18:01:18 +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-07 18:01:18 +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-07 18:01:18 +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-07 18:01:18 +0000
@@ -1,1 +1,1 @@
-usr/lib/*/libmirserver.so.9
+usr/lib/*/libmirserver.so.11

=== 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-07 18:01:18 +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-07 18:01:18 +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

=== 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-07 18:01:18 +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-07 18:01:18 +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-07 18:01:18 +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-07 18:01:18 +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-07 18:01:18 +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-07 18:01:18 +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-07 18:01:18 +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-07 18:01:18 +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-07 18:01:18 +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-07 18:01:18 +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-07 18:01:18 +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"
@@ -55,6 +55,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
@@ -248,7 +249,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 +350,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]

=== 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-07 18:01:18 +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-07 18:01:18 +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-07 18:01:18 +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-07 18:01:18 +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-07 18:01:18 +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-07 18:01:18 +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-07 18:01:18 +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
@@ -195,6 +197,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 +213,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,6 +280,8 @@
     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::SessionContainer>  shell_session_container;
     CachedPtr<shell::FocusSetter>       shell_focus_setter;
@@ -310,6 +316,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-07 18:01:18 +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-07 18:01:18 +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-07 18:01:18 +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-07 18:01:18 +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-07 18:01:18 +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-07 18:01:18 +0000
@@ -44,7 +44,7 @@
 class SurfaceController;
 struct SurfaceCreationParameters;
 
-class Surface : public frontend::ClientTrackingSurface, public shell::SurfaceBufferAccess
+class Surface : public frontend::Surface, public shell::SurfaceBufferAccess
 {
 public:
     Surface(
@@ -86,8 +86,11 @@
     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);
+
+    virtual void resize(geometry::Size const& size);
+
 private:
     bool set_type(MirSurfaceType t);  // Use configure() to make public changes
     bool set_state(MirSurfaceState s);

=== modified file 'include/server/mir/surfaces/buffer_stream_factory.h'
--- include/server/mir/surfaces/buffer_stream_factory.h	2013-08-28 03:41:48 +0000
+++ include/server/mir/surfaces/buffer_stream_factory.h	2013-11-07 18:01:18 +0000
@@ -25,18 +25,17 @@
 
 namespace mir
 {
+namespace compositor { class BufferStream; }
 namespace graphics { struct BufferProperties; }
 
 namespace surfaces
 {
-class BufferStream;
-
 class BufferStreamFactory
 {
 public:
-    virtual ~BufferStreamFactory() {}
+    virtual ~BufferStreamFactory() = default;
 
-    virtual std::shared_ptr<BufferStream> create_buffer_stream(
+    virtual std::shared_ptr<compositor::BufferStream> create_buffer_stream(
         graphics::BufferProperties const& buffer_properties) = 0;
 
 protected:

=== modified file 'include/server/mir/surfaces/surface.h'
--- include/server/mir/surfaces/surface.h	2013-08-29 09:20:06 +0000
+++ include/server/mir/surfaces/surface.h	2013-11-07 18:01:18 +0000
@@ -34,6 +34,7 @@
 {
 class CompositingCriteria;
 struct BufferIPCPackage;
+class BufferStream;
 }
 namespace graphics
 {
@@ -47,7 +48,7 @@
 namespace surfaces
 {
 class SurfaceState;
-class BufferStream;
+class SurfacesReport;
 
 // 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).
@@ -55,8 +56,9 @@
 {
 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);
+            std::shared_ptr<compositor::BufferStream> const& buffer_stream,
+            std::shared_ptr<input::InputChannel> const& input_channel,
+            std::shared_ptr<SurfacesReport> const& report);
 
     ~Surface();
 
@@ -66,7 +68,6 @@
     void set_alpha(float alpha);
     void set_hidden(bool is_hidden);
 
-    /* From Renderable */
     geometry::Point top_left() const;
     geometry::Size size() const;
 
@@ -86,13 +87,17 @@
 
     std::shared_ptr<compositor::CompositingCriteria> compositing_criteria();
 
-    std::shared_ptr<BufferStream> buffer_stream() const;
+    std::shared_ptr<compositor::BufferStream> buffer_stream() const;
 
     std::shared_ptr<input::Surface> input_surface() const;
+
+    void resize(geometry::Size const& size);
+
 private:
     std::shared_ptr<surfaces::SurfaceState> surface_state;
-    std::shared_ptr<BufferStream> surface_buffer_stream;
+    std::shared_ptr<compositor::BufferStream> surface_buffer_stream;
     std::shared_ptr<input::InputChannel> const server_input_channel;
+    std::shared_ptr<SurfacesReport> const report;
     bool surface_in_startup;
 };
 

=== modified file 'include/server/mir/surfaces/surface_controller.h'
--- include/server/mir/surfaces/surface_controller.h	2013-08-28 03:41:48 +0000
+++ include/server/mir/surfaces/surface_controller.h	2013-11-07 18:01:18 +0000
@@ -45,7 +45,7 @@
 
     virtual void raise(std::weak_ptr<Surface> const& surface);
 
-protected:
+private:
     std::shared_ptr<SurfaceStackModel> const surface_stack;
 };
 

=== added file 'include/server/mir/surfaces/surfaces_report.h'
--- include/server/mir/surfaces/surfaces_report.h	1970-01-01 00:00:00 +0000
+++ include/server/mir/surfaces/surfaces_report.h	2013-11-07 18:01:18 +0000
@@ -0,0 +1,60 @@
+/*
+ * Copyright © 2013 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Alan Griffiths <[e-mail]>
+ */
+
+
+#ifndef MIR_SURFACES_SURFACES_REPORT_H_
+#define MIR_SURFACES_SURFACES_REPORT_H_
+
+#include <memory>
+
+namespace mir
+{
+namespace surfaces
+{
+class Surface;
+
+class SurfacesReport
+{
+public:
+    virtual void surface_created(Surface* const surface) = 0;
+    virtual void surface_added(Surface* const surface) = 0;
+
+    virtual void surface_removed(Surface* const surface) = 0;
+    virtual void surface_deleted(Surface* const surface) = 0;
+
+protected:
+    SurfacesReport() = default;
+    virtual ~SurfacesReport() = default;
+    SurfacesReport(SurfacesReport const&) = delete;
+    SurfacesReport& operator=(SurfacesReport const&) = delete;
+};
+
+class NullSurfacesReport : public SurfacesReport
+{
+public:
+    virtual void surface_created(Surface* const /*surface*/) override;
+    virtual void surface_added(Surface* const /*surface*/) override;
+
+    virtual void surface_removed(Surface* const /*surface*/) override;
+    virtual void surface_deleted(Surface* const /*surface*/) override;
+};
+}
+}
+
+
+#endif /* MIR_SURFACES_SURFACES_REPORT_H_ */

=== modified file 'include/test/mir_test/draw/android_graphics.h'
--- include/test/mir_test/draw/android_graphics.h	2013-10-17 05:51:24 +0000
+++ include/test/mir_test/draw/android_graphics.h	2013-11-07 18:01:18 +0000
@@ -19,7 +19,7 @@
 #define MIR_TEST_DRAW_ANDROID_GRAPHICS
 
 #include "mir_toolkit/mir_client_library.h"
-#include "mir/surfaces/buffer_stream.h"
+#include "mir/compositor/buffer_stream.h"
 #include "mir/geometry/size.h"
 
 #include <hardware/gralloc.h>

=== removed file 'include/test/mir_test_doubles/mock_android_framebuffer_window.h'
--- include/test/mir_test_doubles/mock_android_framebuffer_window.h	2013-03-21 19:15:14 +0000
+++ include/test/mir_test_doubles/mock_android_framebuffer_window.h	1970-01-01 00:00:00 +0000
@@ -1,46 +0,0 @@
-/*
- * Copyright © 2013 Canonical Ltd.
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU 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 General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- *
- * Authored by: Kevin DuBois <[e-mail]>
- */
-
-#ifndef MIR_TEST_DOUBLES_MOCK_ANDROID_FRAMEBUFFER_WINDOW_H_
-#define MIR_TEST_DOUBLES_MOCK_ANDROID_FRAMEBUFFER_WINDOW_H_
-
-#include "src/server/graphics/android/android_framebuffer_window_query.h"
-#include <gmock/gmock.h>
-
-namespace mir
-{
-namespace test
-{
-namespace doubles
-{
-
-class MockAndroidFramebufferWindow : public mir::graphics::android::AndroidFramebufferWindowQuery
-{
-public:
-    MockAndroidFramebufferWindow() {}
-    ~MockAndroidFramebufferWindow() {}
-
-    MOCK_CONST_METHOD0(android_native_window_type, EGLNativeWindowType());
-    MOCK_CONST_METHOD1(android_display_egl_config, EGLConfig(EGLDisplay));
-};
-
-}
-}
-}
-
-#endif /* MIR_TEST_DOUBLES_MOCK_ANDROID_FRAMEBUFFER_WINDOW_H_ */

=== modified file 'include/test/mir_test_doubles/mock_buffer_bundle.h'
--- include/test/mir_test_doubles/mock_buffer_bundle.h	2013-08-28 03:41:48 +0000
+++ include/test/mir_test_doubles/mock_buffer_bundle.h	2013-11-07 18:01:18 +0000
@@ -47,6 +47,7 @@
     MOCK_CONST_METHOD0(properties, graphics::BufferProperties());
     MOCK_METHOD0(force_client_abort, void());
     MOCK_METHOD0(force_requests_to_complete, void());
+    MOCK_METHOD1(resize, void(const geometry::Size &));
 };
 
 }

=== modified file 'include/test/mir_test_doubles/mock_buffer_stream.h'
--- include/test/mir_test_doubles/mock_buffer_stream.h	2013-08-28 03:41:48 +0000
+++ include/test/mir_test_doubles/mock_buffer_stream.h	2013-11-07 18:01:18 +0000
@@ -19,7 +19,7 @@
 #ifndef MIR_TEST_DOUBLES_MOCK_BUFFER_STREAM_H_
 #define MIR_TEST_DOUBLES_MOCK_BUFFER_STREAM_H_
 
-#include "mir/surfaces/buffer_stream.h"
+#include "mir/compositor/buffer_stream.h"
 
 #include <gmock/gmock.h>
 
@@ -29,7 +29,7 @@
 {
 namespace doubles
 {
-struct MockBufferStream : public surfaces::BufferStream
+struct MockBufferStream : public compositor::BufferStream
 {
     MOCK_METHOD0(secure_client_buffer, std::shared_ptr<graphics::Buffer>());
     MOCK_METHOD1(lock_compositor_buffer,
@@ -38,6 +38,7 @@
 
     MOCK_METHOD0(get_stream_pixel_format, geometry::PixelFormat());
     MOCK_METHOD0(stream_size, geometry::Size());
+    MOCK_METHOD1(resize, void(geometry::Size const&));
     MOCK_METHOD0(force_client_completion, void());
     MOCK_METHOD1(allow_framedropping, void(bool));
     MOCK_METHOD0(force_requests_to_complete, void());

=== renamed file 'include/test/mir_test_doubles/mock_display_support_provider.h' => 'include/test/mir_test_doubles/mock_display_device.h'
--- include/test/mir_test_doubles/mock_display_support_provider.h	2013-10-09 00:57:21 +0000
+++ include/test/mir_test_doubles/mock_display_device.h	2013-11-07 18:01:18 +0000
@@ -16,10 +16,10 @@
  * Authored by: Kevin DuBois <[e-mail]>
  */
 
-#ifndef MIR_TEST_DOUBLES_MOCK_DISPLAY_SUPPORT_PROVIDER_H_
-#define MIR_TEST_DOUBLES_MOCK_DISPLAY_SUPPORT_PROVIDER_H_
+#ifndef MIR_TEST_DOUBLES_MOCK_DISPLAY_DEVICE_H_
+#define MIR_TEST_DOUBLES_MOCK_DISPLAY_DEVICE_H_
 
-#include "src/server/graphics/android/display_support_provider.h"
+#include "src/server/graphics/android/display_device.h"
 #include <gmock/gmock.h>
  
 namespace mir
@@ -28,10 +28,10 @@
 {
 namespace doubles
 {
-class MockDisplaySupportProvider : public graphics::android::DisplaySupportProvider
+class MockDisplayDevice : public graphics::android::DisplayDevice
 {
 public:
-    ~MockDisplaySupportProvider() noexcept {}
+    ~MockDisplayDevice() noexcept {}
     MOCK_CONST_METHOD0(display_size, geometry::Size());
     MOCK_CONST_METHOD0(display_format, geometry::PixelFormat());
     MOCK_CONST_METHOD0(number_of_framebuffers_available, unsigned int());
@@ -43,4 +43,4 @@
 }
 }
 }
-#endif /* MIR_TEST_DOUBLES_MOCK_DISPLAY_SUPPORT_PROVIDER_H_ */
+#endif /* MIR_TEST_DOUBLES_MOCK_DISPLAY_DEVICE_H_ */

=== modified file 'include/test/mir_test_doubles/mock_egl.h'
--- include/test/mir_test_doubles/mock_egl.h	2013-06-14 20:19:37 +0000
+++ include/test/mir_test_doubles/mock_egl.h	2013-11-07 18:01:18 +0000
@@ -36,6 +36,23 @@
 namespace doubles
 {
 
+MATCHER_P(AttrMatches, val, std::string("matches"))
+{
+    auto i = 0;
+    while ((val[i] != EGL_NONE) && (arg[i] != EGL_NONE))
+    {
+        if (val[i] != arg[i])
+            return false;
+        i++;
+    }
+
+    if ((val[i] == EGL_NONE) && (arg[i] == EGL_NONE))
+    {
+        return true;
+    }
+    return false;
+}
+
 class MockEGL
 {
 public:

=== modified file 'include/test/mir_test_doubles/mock_focus_setter.h'
--- include/test/mir_test_doubles/mock_focus_setter.h	2013-08-28 03:41:48 +0000
+++ include/test/mir_test_doubles/mock_focus_setter.h	2013-11-07 18:01:18 +0000
@@ -19,7 +19,7 @@
 #ifndef MIR_TEST_DOUBLES_MOCK_FOCUS_SETTER_H_
 #define MIR_TEST_DOUBLES_MOCK_FOCUS_SETTER_H_
 
-#include "mir/shell/focus_setter.h"
+#include "src/server/shell/focus_setter.h"
 
 #include <gmock/gmock.h>
 

=== modified file 'include/test/mir_test_doubles/mock_frontend_surface.h'
--- include/test/mir_test_doubles/mock_frontend_surface.h	2013-08-28 03:41:48 +0000
+++ include/test/mir_test_doubles/mock_frontend_surface.h	2013-11-07 18:01:18 +0000
@@ -29,7 +29,7 @@
 {
 namespace doubles
 {
-struct MockFrontendSurface : public frontend::ClientTrackingSurface
+struct MockFrontendSurface : public frontend::Surface
 {
     MockFrontendSurface()
     {

=== modified file 'include/test/mir_test_doubles/mock_shell_session.h'
--- include/test/mir_test_doubles/mock_shell_session.h	2013-08-28 03:41:48 +0000
+++ include/test/mir_test_doubles/mock_shell_session.h	2013-11-07 18:01:18 +0000
@@ -49,6 +49,8 @@
     
     MOCK_METHOD1(send_display_config, void(graphics::DisplayConfiguration const&));
     MOCK_METHOD3(configure_surface, int(frontend::SurfaceId, MirSurfaceAttrib, int));
+
+    MOCK_METHOD1(set_lifecycle_state, void(MirLifecycleState state));
 };
 
 }

=== modified file 'include/test/mir_test_doubles/mock_surface_renderer.h'
--- include/test/mir_test_doubles/mock_surface_renderer.h	2013-08-28 03:41:48 +0000
+++ include/test/mir_test_doubles/mock_surface_renderer.h	2013-11-07 18:01:18 +0000
@@ -18,8 +18,9 @@
 #ifndef MIR_TEST_DOUBLES_MOCK_SURFACE_RENDERER_H_
 #define MIR_TEST_DOUBLES_MOCK_SURFACE_RENDERER_H_
 
-#include "mir/surfaces/buffer_stream.h"
-#include "mir/compositor/renderer.h"
+#include "mir/compositor/buffer_stream.h"
+#include "src/server/compositor/renderer.h"
+
 #include <gmock/gmock.h>
 
 namespace mir
@@ -32,7 +33,7 @@
 struct MockSurfaceRenderer : public compositor::Renderer
 {
     MOCK_METHOD3(render, void(
-        std::function<void(std::shared_ptr<void> const&)>, compositor::CompositingCriteria const&, surfaces::BufferStream&));
+        std::function<void(std::shared_ptr<void> const&)>, compositor::CompositingCriteria const&, compositor::BufferStream&));
     MOCK_METHOD1(clear, void(unsigned long));
 
     ~MockSurfaceRenderer() noexcept {}

=== modified file 'include/test/mir_test_doubles/mock_surface_state.h'
--- include/test/mir_test_doubles/mock_surface_state.h	2013-10-07 07:56:05 +0000
+++ include/test/mir_test_doubles/mock_surface_state.h	2013-11-07 18:01:18 +0000
@@ -52,6 +52,7 @@
     MOCK_CONST_METHOD0(name, std::string const&());
     MOCK_METHOD2(apply_rotation, void(float, glm::vec3 const&));
     MOCK_METHOD1(move_to, void(geometry::Point));
+    MOCK_METHOD1(resize, void(geometry::Size const&));
     MOCK_CONST_METHOD1(contains, bool(geometry::Point const&));
     MOCK_METHOD1(set_input_region, void(std::vector<geometry::Rectangle> const&));
     MOCK_CONST_METHOD0(alpha, float());

=== modified file 'include/test/mir_test_doubles/null_session_event_sink.h'
--- include/test/mir_test_doubles/null_session_event_sink.h	2013-08-15 09:15:39 +0000
+++ include/test/mir_test_doubles/null_session_event_sink.h	2013-11-07 18:01:18 +0000
@@ -19,7 +19,7 @@
 #ifndef MIR_TEST_DOUBLES_NULL_SESSION_EVENT_SINK_H_
 #define MIR_TEST_DOUBLES_NULL_SESSION_EVENT_SINK_H_
 
-#include "mir/shell/session_event_sink.h"
+#include "src/server/shell/session_event_sink.h"
 
 namespace mir
 {

=== modified file 'include/test/mir_test_doubles/null_snapshot_strategy.h'
--- include/test/mir_test_doubles/null_snapshot_strategy.h	2013-06-25 13:19:15 +0000
+++ include/test/mir_test_doubles/null_snapshot_strategy.h	2013-11-07 18:01:18 +0000
@@ -19,7 +19,7 @@
 #ifndef MIR_TEST_DOUBLES_NULL_SNAPSHOT_STRATEGY_H_
 #define MIR_TEST_DOUBLES_NULL_SNAPSHOT_STRATEGY_H_
 
-#include "mir/shell/snapshot_strategy.h"
+#include "src/server/shell/snapshot_strategy.h"
 
 namespace mir
 {

=== modified file 'include/test/mir_test_doubles/stub_buffer_allocator.h'
--- include/test/mir_test_doubles/stub_buffer_allocator.h	2013-08-28 03:41:48 +0000
+++ include/test/mir_test_doubles/stub_buffer_allocator.h	2013-11-07 18:01:18 +0000
@@ -37,15 +37,9 @@
 
 struct StubBufferAllocator : public graphics::GraphicBufferAllocator
 {
-    StubBufferAllocator() : id{1} {}
-
     std::shared_ptr<graphics::Buffer> alloc_buffer(
-        graphics::BufferProperties const&)
+        graphics::BufferProperties const& properties)
     {
-        graphics::BufferProperties properties{geometry::Size{id, id},
-                                        geometry::PixelFormat::abgr_8888,
-                                        graphics::BufferUsage::hardware};
-        ++id;
         return std::make_shared<StubBuffer>(properties);
     }
 
@@ -53,8 +47,6 @@
     {
         return {};
     }
-
-    unsigned int id;
 };
 
 }

=== modified file 'include/test/mir_test_doubles/stub_buffer_stream.h'
--- include/test/mir_test_doubles/stub_buffer_stream.h	2013-08-28 03:41:48 +0000
+++ include/test/mir_test_doubles/stub_buffer_stream.h	2013-11-07 18:01:18 +0000
@@ -19,7 +19,7 @@
 #ifndef MIR_TEST_DOUBLES_NULL_BUFFER_STREAM_H_
 #define MIR_TEST_DOUBLES_NULL_BUFFER_STREAM_H_
 
-#include <mir/surfaces/buffer_stream.h>
+#include <mir/compositor/buffer_stream.h>
 #include <mir_test_doubles/stub_buffer.h>
 
 namespace mir
@@ -29,7 +29,7 @@
 namespace doubles
 {
 
-class StubBufferStream : public surfaces::BufferStream
+class StubBufferStream : public compositor::BufferStream
 {
 public:
     StubBufferStream()
@@ -62,6 +62,10 @@
         return geometry::Size();
     }
 
+    void resize(geometry::Size const&) override
+    {
+    }
+
     void force_requests_to_complete()
     {
     }

=== added file 'include/test/mir_test_doubles/stub_display_buffer_factory.h'
--- include/test/mir_test_doubles/stub_display_buffer_factory.h	1970-01-01 00:00:00 +0000
+++ include/test/mir_test_doubles/stub_display_buffer_factory.h	2013-11-07 18:01:18 +0000
@@ -0,0 +1,75 @@
+/*
+ * Copyright © 2013 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Kevin DuBois <[e-mail]>
+ */
+
+#ifndef MIR_TEST_DOUBLES_STUB_DISPLAY_BUFFER_FACTORY_H_
+#define MIR_TEST_DOUBLES_STUB_DISPLAY_BUFFER_FACTORY_H_
+
+#include "src/server/graphics/android/android_display_buffer_factory.h"
+#include "stub_display_buffer.h"
+#include "stub_display_device.h"
+#include <gmock/gmock.h>
+
+namespace mir
+{
+namespace test
+{
+namespace doubles
+{
+struct StubDisplayBufferFactory : public graphics::android::AndroidDisplayBufferFactory
+{
+    StubDisplayBufferFactory(std::shared_ptr<graphics::android::DisplayDevice> const& stub_dev, geometry::Size sz)
+        : stub_dev(stub_dev), sz(sz)
+    {
+    }
+
+    StubDisplayBufferFactory()
+        : StubDisplayBufferFactory(std::make_shared<StubDisplayDevice>(), geometry::Size{0,0})
+    {
+    }
+
+    StubDisplayBufferFactory(geometry::Size sz)
+        : StubDisplayBufferFactory(std::make_shared<StubDisplayDevice>(), sz)
+    {
+    }
+
+    StubDisplayBufferFactory(std::shared_ptr<graphics::android::DisplayDevice> const& stub_dev)
+        : stub_dev(stub_dev), sz(geometry::Size{0,0})
+    {
+    }
+
+    std::unique_ptr<graphics::DisplayBuffer> create_display_buffer(
+        std::shared_ptr<graphics::android::DisplayDevice> const&,
+        EGLDisplay, EGLConfig, EGLContext)
+    {
+        return std::unique_ptr<graphics::DisplayBuffer>(
+                new StubDisplayBuffer(geometry::Rectangle{{0,0},sz}));
+    }
+    
+    std::shared_ptr<graphics::android::DisplayDevice> create_display_device()
+    {
+        return stub_dev;
+    }
+
+    std::shared_ptr<graphics::android::DisplayDevice> const stub_dev;
+    geometry::Size sz;
+};
+}
+}
+} // namespace mir
+
+#endif /* MIR_TEST_DOUBLES_STUB_DISPLAY_BUFFER_FACTORY_H_ */

=== renamed file 'include/test/mir_test_doubles/stub_display_support_provider.h' => 'include/test/mir_test_doubles/stub_display_device.h'
--- include/test/mir_test_doubles/stub_display_support_provider.h	2013-10-18 21:15:15 +0000
+++ include/test/mir_test_doubles/stub_display_device.h	2013-11-07 18:01:18 +0000
@@ -15,10 +15,10 @@
  *
  */
 
-#ifndef MIR_TEST_DOUBLES_STUB_DISPLAY_SUPPORT_PROVIDER_H_
-#define MIR_TEST_DOUBLES_STUB_DISPLAY_SUPPORT_PROVIDER_H_
+#ifndef MIR_TEST_DOUBLES_STUB_DISPLAY_DEVICE_H_
+#define MIR_TEST_DOUBLES_STUB_DISPLAY_DEVICE_H_
 
-#include "src/server/graphics/android/display_support_provider.h"
+#include "src/server/graphics/android/display_device.h"
  
 namespace mir
 {
@@ -27,26 +27,28 @@
 namespace doubles
 {
 
-struct StubDisplaySupportProvider : public graphics::android::DisplaySupportProvider
+struct StubDisplayDevice : public graphics::android::DisplayDevice
 {
-    StubDisplaySupportProvider(geometry::Size sz)
+    StubDisplayDevice(geometry::Size sz)
      : sz(sz)
     {
     }
-    StubDisplaySupportProvider()
-     : StubDisplaySupportProvider({0,0})
+
+    StubDisplayDevice()
+     : StubDisplayDevice({0,0})
     {
     }
 
-    ~StubDisplaySupportProvider() noexcept {}
+    ~StubDisplayDevice() noexcept {}
 
     geometry::Size display_size() const { return sz; }
-    geometry::PixelFormat display_format() const { return geometry::PixelFormat(); }
+    geometry::PixelFormat display_format() const { return geometry::PixelFormat::abgr_8888; }
     unsigned int number_of_framebuffers_available() const { return 0; }
     void set_next_frontbuffer(std::shared_ptr<mir::graphics::Buffer> const&) {}
     void sync_to_display(bool) {}
     void mode(MirPowerMode) {}
     void commit_frame(EGLDisplay, EGLSurface) {}
+
 private:
     geometry::Size sz;
 };
@@ -54,4 +56,4 @@
 }
 }
 }
-#endif /* MIR_TEST_DOUBLES_STUB_DISPLAY_SUPPORT_PROVIDER_H_ */
+#endif /* MIR_TEST_DOUBLES_STUB_DISPLAY_DEVICE_H_ */

=== added file 'include/test/mir_test_doubles/stub_driver_interpreter.h'
--- include/test/mir_test_doubles/stub_driver_interpreter.h	1970-01-01 00:00:00 +0000
+++ include/test/mir_test_doubles/stub_driver_interpreter.h	2013-11-07 18:01:18 +0000
@@ -0,0 +1,75 @@
+/*
+ * Copyright © 2012 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Kevin DuBois <[e-mail]>
+ */
+
+#ifndef MIR_TEST_DOUBLES_STUB_DRIVER_INTERPRETER_H_
+#define MIR_TEST_DOUBLES_STUB_DRIVER_INTERPRETER_H_
+
+#include "mir/graphics/android/android_driver_interpreter.h"
+
+namespace mir
+{
+namespace test
+{
+namespace doubles
+{
+
+class StubDriverInterpreter : public graphics::android::AndroidDriverInterpreter
+{
+public:
+    StubDriverInterpreter(mir::geometry::Size sz, int visual_id)
+     : sz{sz},
+       visual_id{visual_id}
+    {
+    }
+
+    StubDriverInterpreter()
+     : StubDriverInterpreter(mir::geometry::Size{44,22}, 5)
+    {
+    }
+
+    mir::graphics::NativeBuffer* driver_requests_buffer()
+    {
+        return nullptr;
+    }
+    void driver_returns_buffer(ANativeWindowBuffer*, int)
+    {
+    }
+    void dispatch_driver_request_format(int) 
+    {
+    }
+    int driver_requests_info(int index) const
+    {
+        if (index == NATIVE_WINDOW_WIDTH)
+            return sz.width.as_uint32_t();
+        if (index == NATIVE_WINDOW_HEIGHT)
+            return sz.height.as_uint32_t();
+        if (index == NATIVE_WINDOW_FORMAT)
+            return visual_id;
+        return 0;
+    }
+    void sync_to_display(bool)
+    {
+    }
+private:
+    mir::geometry::Size sz;
+    int visual_id;
+};
+}
+}
+}
+#endif /* MIR_TEST_DOUBLES_STUB_BUFFER_H_ */

=== modified file 'include/test/mir_test_doubles/stub_ipc_factory.h'
--- include/test/mir_test_doubles/stub_ipc_factory.h	2013-08-28 03:41:48 +0000
+++ include/test/mir_test_doubles/stub_ipc_factory.h	2013-11-07 18:01:18 +0000
@@ -21,8 +21,8 @@
 #define MIR_TEST_DOUBLES_STUB_IPC_FACTORY_H_
 
 #include "mir_test/fake_shared.h"
-#include "mir/frontend/protobuf_ipc_factory.h"
-#include "mir/frontend/resource_cache.h"
+#include "src/server/frontend/protobuf_ipc_factory.h"
+#include "src/server/frontend/resource_cache.h"
 #include "mir/frontend/null_message_processor_report.h"
 
 namespace mir

=== modified file 'include/test/mir_test_doubles/stub_shell_session.h'
--- include/test/mir_test_doubles/stub_shell_session.h	2013-08-13 22:20:37 +0000
+++ include/test/mir_test_doubles/stub_shell_session.h	2013-11-07 18:01:18 +0000
@@ -71,6 +71,10 @@
     {
         return std::shared_ptr<shell::Surface>();
     }
+
+    void set_lifecycle_state(MirLifecycleState /*state*/)
+    {
+    }
 };
 
 }

=== modified file 'include/test/mir_test_doubles/stub_surface.h'
--- include/test/mir_test_doubles/stub_surface.h	2013-10-15 08:53:10 +0000
+++ include/test/mir_test_doubles/stub_surface.h	2013-11-07 18:01:18 +0000
@@ -28,7 +28,7 @@
 namespace doubles
 {
 
-class StubSurface : public frontend::ClientTrackingSurface
+class StubSurface : public frontend::Surface
 {
 public:
     virtual ~StubSurface() = default;

=== modified file 'include/test/mir_test_doubles/stub_surface_builder.h'
--- include/test/mir_test_doubles/stub_surface_builder.h	2013-08-28 03:41:48 +0000
+++ include/test/mir_test_doubles/stub_surface_builder.h	2013-11-07 18:01:18 +0000
@@ -22,6 +22,7 @@
 
 #include "mir/shell/surface_builder.h"
 #include "mir/surfaces/surface.h"
+#include "mir/surfaces/surfaces_report.h"
 #include "mir/shell/surface_creation_parameters.h"
 
 #include "mir_test_doubles/stub_buffer_stream.h"
@@ -47,7 +48,10 @@
     {
         auto state = std::make_shared<MockSurfaceState>();
         dummy_surface = std::make_shared<surfaces::Surface>(
-            state, buffer_stream, std::shared_ptr<input::InputChannel>());
+            state, buffer_stream,
+            std::shared_ptr<input::InputChannel>(),
+            report);
+
         return dummy_surface;
     }
 
@@ -55,8 +59,10 @@
     {
     }
 private:
-    std::shared_ptr<surfaces::BufferStream> const buffer_stream;
+    std::shared_ptr<compositor::BufferStream> const buffer_stream;
     std::shared_ptr<surfaces::Surface>  dummy_surface;
+    std::shared_ptr<surfaces::SurfacesReport> report = std::make_shared<surfaces::NullSurfacesReport>();
+
 };