Merge lp:~raof/mir/fix-1253876 into lp:mir/0.1

[Chris Halse Rogers]

GBMDisplayTest: Timeout and fail the test rather than hanging indefinitely

GBMDisplayTest: Timeout and fail the test rather than hanging indefinitely

[Daniel van Vugt (vanvugt)]

Wrong diff, wrong target branch :)

review: Needs Resubmitting

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:1249
http://jenkins.qa.ubuntu.com/job/mir-ci/1618/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-android-trusty-i386-build/260
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-clang-trusty-amd64-build/257
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-trusty-amd64-ci/16/console
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-trusty-armhf-ci/16
        deb: http://jenkins.qa.ubuntu.com/job/mir-trusty-armhf-ci/16/artifact/work/output/*zip*/output.zip

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

review: Needs Fixing (continuous-integration)

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

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

=== modified file '3rd_party/android-input/android/frameworks/base/services/input/InputReader.cpp'
--- 3rd_party/android-input/android/frameworks/base/services/input/InputReader.cpp	2013-10-15 08:53:10 +0000
+++ 3rd_party/android-input/android/frameworks/base/services/input/InputReader.cpp	2013-11-22 04:49:56 +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-22 04:49:56 +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-22 04:49:56 +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-22 04:49:56 +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-22 04:49:56 +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-22 04:49:56 +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-22 04:49:56 +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-22 04:49:56 +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 'debian/control'
--- debian/control	2013-11-06 03:17:35 +0000
+++ debian/control	2013-11-22 04:49:56 +0000
@@ -69,7 +69,7 @@
  .
  Contains the protocol's definition files.
 
-Package: libmirserver10
+Package: libmirserver11
 Section: libs
 Architecture: i386 amd64 armhf arm64
 Multi-Arch: same
@@ -115,7 +115,7 @@
 Architecture: i386 amd64 armhf arm64
 Multi-Arch: same
 Pre-Depends: ${misc:Pre-Depends}
-Depends: libmirserver10 (= ${binary:Version}),
+Depends: libmirserver11 (= ${binary:Version}),
          libmirprotobuf-dev (= ${binary:Version}),
          mircommon-dev (= ${binary:Version}),
          libglm-dev,

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

=== modified file 'include/server/mir/input/android/dispatcher_input_configuration.h'
--- include/server/mir/input/android/dispatcher_input_configuration.h	2013-09-10 16:42:04 +0000
+++ include/server/mir/input/android/dispatcher_input_configuration.h	2013-11-22 04:49:56 +0000
@@ -90,7 +90,7 @@
                               std::shared_ptr<input::InputReport> const& input_report);
     virtual ~DispatcherInputConfiguration();
 
-    std::shared_ptr<surfaces::InputRegistrar> the_input_registrar();
+    std::shared_ptr<scene::InputRegistrar> the_input_registrar();
     std::shared_ptr<shell::InputTargeter> the_input_targeter();
     std::shared_ptr<input::InputManager> the_input_manager();
 

=== modified file 'include/server/mir/input/input_configuration.h'
--- include/server/mir/input/input_configuration.h	2013-05-24 19:27:37 +0000
+++ include/server/mir/input/input_configuration.h	2013-11-22 04:49:56 +0000
@@ -23,7 +23,7 @@
 
 namespace mir
 {
-namespace surfaces
+namespace scene
 {
 class InputRegistrar;
 }
@@ -41,7 +41,7 @@
 public:
     virtual ~InputConfiguration() {}
 
-    virtual std::shared_ptr<surfaces::InputRegistrar> the_input_registrar() = 0;
+    virtual std::shared_ptr<scene::InputRegistrar> the_input_registrar() = 0;
     virtual std::shared_ptr<shell::InputTargeter> the_input_targeter() = 0;
     virtual std::shared_ptr<input::InputManager> the_input_manager() = 0;
     

=== renamed directory 'include/server/mir/surfaces' => 'include/server/mir/scene'
=== modified file 'include/server/mir/scene/buffer_stream_factory.h'
--- include/server/mir/surfaces/buffer_stream_factory.h	2013-11-06 03:17:35 +0000
+++ include/server/mir/scene/buffer_stream_factory.h	2013-11-22 04:49:56 +0000
@@ -18,8 +18,8 @@
  *  Thomas Voss <[e-mail]>
  */
 
-#ifndef MIR_SURFACES_BUFFER_STREAM_FACTORY_H_
-#define MIR_SURFACES_BUFFER_STREAM_FACTORY_H_
+#ifndef MIR_SCENE_BUFFER_STREAM_FACTORY_H_
+#define MIR_SCENE_BUFFER_STREAM_FACTORY_H_
 
 #include <memory>
 
@@ -28,7 +28,7 @@
 namespace compositor { class BufferStream; }
 namespace graphics { struct BufferProperties; }
 
-namespace surfaces
+namespace scene
 {
 class BufferStreamFactory
 {
@@ -47,4 +47,4 @@
 }
 }
 
-#endif // MIR_SURFACES_BUFFER_STREAM_FACTORY_H_
+#endif // MIR_SCENE_BUFFER_STREAM_FACTORY_H_

=== modified file 'include/server/mir/scene/depth_id.h'
--- include/server/mir/surfaces/depth_id.h	2013-08-28 03:41:48 +0000
+++ include/server/mir/scene/depth_id.h	2013-11-22 04:49:56 +0000
@@ -16,14 +16,14 @@
  * Authored By: Robert Carr <[e-mail]>
  */
 
-#ifndef MIR_SURFACES_DEPTH_ID_H_
-#define MIR_SURFACES_DEPTH_ID_H_
+#ifndef MIR_SCENE_DEPTH_ID_H_
+#define MIR_SCENE_DEPTH_ID_H_
 
 #include "mir/int_wrapper.h"
 
 namespace mir
 {
-namespace surfaces
+namespace scene
 {
 namespace detail { struct DepthIdIdTag; }