Merge lp:mir/0.11 into lp:mir/ubuntu

[Robert Carr]

Release 0.11

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:2282
No commit message was specified in the merge proposal. Click on the following link and set the commit message (if you want a jenkins rebuild you need to trigger it yourself):
https://code.launchpad.net/~mir-team/mir/0.11/+merge/248221/+edit-commit-message

http://jenkins.qa.ubuntu.com/job/mir-ubuntu-ci/34/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-android-vivid-i386-build/1148
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-clang-vivid-amd64-build/1147
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-ubuntu-vivid-amd64-ci/19
        deb: http://jenkins.qa.ubuntu.com/job/mir-ubuntu-vivid-amd64-ci/19/artifact/work/output/*zip*/output.zip
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-ubuntu-vivid-armhf-ci/22/console

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

review: Needs Fixing (continuous-integration)

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:2283
http://jenkins.qa.ubuntu.com/job/mir-ubuntu-ci/35/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-android-vivid-i386-build/1156
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-clang-vivid-amd64-build/1155
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-ubuntu-vivid-amd64-ci/20
        deb: http://jenkins.qa.ubuntu.com/job/mir-ubuntu-vivid-amd64-ci/20/artifact/work/output/*zip*/output.zip
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-ubuntu-vivid-armhf-ci/23/console

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

review: Needs Fixing (continuous-integration)

[Daniel van Vugt (vanvugt)]

TODOs and general lack of text in debian/changelog. Remind me to fill it out today...

review: Needs Fixing

[Daniel van Vugt (vanvugt)]

review: Abstain

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:2284
http://jenkins.qa.ubuntu.com/job/mir-ubuntu-ci/36/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-android-vivid-i386-build/1170
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-clang-vivid-amd64-build/1169
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-ubuntu-vivid-amd64-ci/21
        deb: http://jenkins.qa.ubuntu.com/job/mir-ubuntu-vivid-amd64-ci/21/artifact/work/output/*zip*/output.zip
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-ubuntu-vivid-armhf-ci/24/console

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

review: Needs Fixing (continuous-integration)

[Daniel van Vugt (vanvugt)]

^^ I think the failure is bug 1407863 which has a fix on lp:mir. That and other changes will be merged here tomorrow-ish apparently.

[lp:mir/0.11]

2283. By Robert Carr <racarr@ocelot> on 2015-02-03

Merge trunk

2284. By Robert Carr <racarr@ocelot> on 2015-02-03

Merge lp:~vanvugt/mir/fix-buffers_ready_for_compositor

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:2285
http://jenkins.qa.ubuntu.com/job/mir-ubuntu-ci/37/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-android-vivid-i386-build/1189
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-clang-vivid-amd64-build/1188
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-ubuntu-vivid-amd64-ci/22
        deb: http://jenkins.qa.ubuntu.com/job/mir-ubuntu-vivid-amd64-ci/22/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-ubuntu-vivid-armhf-ci/25
        deb: http://jenkins.qa.ubuntu.com/job/mir-ubuntu-vivid-armhf-ci/25/artifact/work/output/*zip*/output.zip

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

review: Approve (continuous-integration)

[lp:mir/0.11]

2285. By Robert Carr on 2015-02-06

Cherrypick lp:~mir-team/mir/repair-client-abi 2303...2305

2286. By Robert Carr on 2015-02-06

Merge changelog

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:2286
http://jenkins.qa.ubuntu.com/job/mir-ubuntu-ci/38/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-android-vivid-i386-build/1242
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-clang-vivid-amd64-build/1241
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-ubuntu-vivid-amd64-ci/23
        deb: http://jenkins.qa.ubuntu.com/job/mir-ubuntu-vivid-amd64-ci/23/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-ubuntu-vivid-armhf-ci/26
        deb: http://jenkins.qa.ubuntu.com/job/mir-ubuntu-vivid-armhf-ci/26/artifact/work/output/*zip*/output.zip

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

review: Approve (continuous-integration)

[lp:mir/0.11]

2287. By Robert Carr on 2015-02-09

Cherrypick lp:~mir-team/mir/catch-exceptions-at-android-driver-boundary

[Mathieu Trudel-Lapierre (cyphermox)]

Seems to me like there is a mir-client-platform-android-dev package missing, given that there is mir-client-platform-mesa-dev.

Also, I see debian/changelog doesn't list the changes to packages provided aside from the ABI changes; I think those and the relevant changes to debian/rules should be listed as well.

Finally, this is a rather big changeset, I'd feel much more confident if it could go through review from the usual trainguards too, since I haven't dealt with Mir updates for almost a year and I remember there are a few details that needed to be followed when publishing it.

Has the upgrade path been tested using the PPA to make sure packages update themselves safely on all types of devices (mesa and android) ?

review: Needs Information

[lp:mir/0.11]

2288. By Robert Carr on 2015-02-09

Update changelog

[Robert Carr (robertcarr)]

Hey. Thanks :)

>> Seems to me like there is a mir-client-platform-android-dev package missing, given that there is >> mir-client-platform-mesa-dev.

I think this just isn't required. For mesa Mir has to publish some new interfaces for mesa EGL to plug in to but on android android EGL publishes the interfaces for Mir to plug in to.

>> Also, I see debian/changelog doesn't list the changes to packages provided aside from the ABI
>> changes; I think those and the relevant changes to debian/rules should be listed as well.

Made a best effort to summarize...feverish state making it difficult to require details. If more info required seek RAOF.

>> Has the upgrade path been tested using the PPA to make sure packages update themselves safely >> on all types of devices (mesa and android) ?

Yes :) Tested on Desktop and Android

>> Finally, this is a rather big changeset, I'd feel much more confident if it could go through
>> review from the usual trainguards too, since I haven't dealt with Mir updates for almost a year >> and I remember there are a few details that needed to be followed when publishing it.

Makes sense to me

[Robert Carr (robertcarr)]

The changelog commit was missing from the silo.

=== modified file '3rd_party/android-deps/std/Condition.h'
--- 3rd_party/android-deps/std/Condition.h	2013-05-03 16:38:07 +0000
+++ 3rd_party/android-deps/std/Condition.h	2015-02-09 23:59:09 +0000
@@ -32,7 +32,7 @@
 inline void broadcast(Condition& c) { c.notify_all(); }
 
 template <typename Lock>
-inline void waitRelative(Condition& c, Lock& l, nsecs_t reltime)
+inline void waitRelative(Condition& c, Lock& l, std::chrono::nanoseconds reltime)
 {
     c.wait_for(l, std::chrono::nanoseconds(reltime));
 }

=== modified file '3rd_party/android-deps/utils/Timers.h'
--- 3rd_party/android-deps/utils/Timers.h	2013-03-13 04:54:15 +0000
+++ 3rd_party/android-deps/utils/Timers.h	2015-02-09 23:59:09 +0000
@@ -23,6 +23,7 @@
 #include <stdint.h>
 #include <sys/types.h>
 #include <sys/time.h>
+#include <chrono>
 
 // ------------------------------------------------------------------
 // C API
@@ -31,48 +32,48 @@
 extern "C" {
 #endif
 
-typedef int64_t nsecs_t;       // nano-seconds
+typedef int64_t nsecs_t;
 
-static inline nsecs_t seconds_to_nanoseconds(nsecs_t secs)
+static inline std::chrono::nanoseconds seconds_to_nanoseconds(std::chrono::nanoseconds secs)
 {
     return secs*1000000000;
 }
 
-static inline nsecs_t milliseconds_to_nanoseconds(nsecs_t secs)
+static inline std::chrono::nanoseconds milliseconds_to_nanoseconds(std::chrono::nanoseconds secs)
 {
     return secs*1000000;
 }
 
-static inline nsecs_t microseconds_to_nanoseconds(nsecs_t secs)
+static inline std::chrono::nanoseconds microseconds_to_nanoseconds(std::chrono::nanoseconds secs)
 {
     return secs*1000;
 }
 
-static inline nsecs_t nanoseconds_to_seconds(nsecs_t secs)
+static inline std::chrono::nanoseconds nanoseconds_to_seconds(std::chrono::nanoseconds secs)
 {
     return secs/1000000000;
 }
 
-static inline nsecs_t nanoseconds_to_milliseconds(nsecs_t secs)
+static inline std::chrono::nanoseconds nanoseconds_to_milliseconds(std::chrono::nanoseconds secs)
 {
     return secs/1000000;
 }
 
-static inline nsecs_t nanoseconds_to_microseconds(nsecs_t secs)
+static inline std::chrono::nanoseconds nanoseconds_to_microseconds(std::chrono::nanoseconds secs)
 {
     return secs/1000;
 }
 
-static inline nsecs_t s2ns(nsecs_t v)  {return seconds_to_nanoseconds(v);}
-static inline nsecs_t ms2ns(nsecs_t v) {return milliseconds_to_nanoseconds(v);}
-static inline nsecs_t us2ns(nsecs_t v) {return microseconds_to_nanoseconds(v);}
-static inline nsecs_t ns2s(nsecs_t v)  {return nanoseconds_to_seconds(v);}
-static inline nsecs_t ns2ms(nsecs_t v) {return nanoseconds_to_milliseconds(v);}
-static inline nsecs_t ns2us(nsecs_t v) {return nanoseconds_to_microseconds(v);}
+static inline std::chrono::nanoseconds s2ns(std::chrono::nanoseconds v)  {return seconds_to_nanoseconds(v);}
+static inline std::chrono::nanoseconds ms2ns(std::chrono::nanoseconds v) {return milliseconds_to_nanoseconds(v);}
+static inline std::chrono::nanoseconds us2ns(std::chrono::nanoseconds v) {return microseconds_to_nanoseconds(v);}
+static inline std::chrono::nanoseconds ns2s(std::chrono::nanoseconds v)  {return nanoseconds_to_seconds(v);}
+static inline std::chrono::nanoseconds ns2ms(std::chrono::nanoseconds v) {return nanoseconds_to_milliseconds(v);}
+static inline std::chrono::nanoseconds ns2us(std::chrono::nanoseconds v) {return nanoseconds_to_microseconds(v);}
 
-static inline nsecs_t seconds(nsecs_t v)      { return s2ns(v); }
-static inline nsecs_t milliseconds(nsecs_t v) { return ms2ns(v); }
-static inline nsecs_t microseconds(nsecs_t v) { return us2ns(v); }
+static inline std::chrono::nanoseconds seconds(std::chrono::nanoseconds v)      { return s2ns(v); }
+static inline std::chrono::nanoseconds milliseconds(std::chrono::nanoseconds v) { return ms2ns(v); }
+static inline std::chrono::nanoseconds microseconds(std::chrono::nanoseconds v) { return us2ns(v); }
 
 enum {
     SYSTEM_TIME_REALTIME = 0,  // system-wide realtime clock
@@ -83,9 +84,9 @@
     
 // return the system-time according to the specified clock
 #ifdef __cplusplus
-nsecs_t systemTime(int clock = SYSTEM_TIME_MONOTONIC);
+std::chrono::nanoseconds systemTime(int clock = SYSTEM_TIME_MONOTONIC);
 #else
-nsecs_t systemTime(int clock);
+std::chrono::nanoseconds systemTime(int clock);
 #endif // def __cplusplus
 
 /**
@@ -96,7 +97,7 @@
  * Otherwise, returns the difference between the reference time and timeout time
  * rounded up to the next millisecond.
  */
-int toMillisecondTimeoutDelay(nsecs_t referenceTime, nsecs_t timeoutTime);
+int toMillisecondTimeoutDelay(std::chrono::nanoseconds referenceTime, std::chrono::nanoseconds timeoutTime);
 
 #ifdef __cplusplus
 } // extern "C"

=== modified file '3rd_party/android-input/android/frameworks/base/include/androidfw/Input.h'
--- 3rd_party/android-input/android/frameworks/base/include/androidfw/Input.h	2014-03-06 06:05:17 +0000
+++ 3rd_party/android-input/android/frameworks/base/include/androidfw/Input.h	2015-02-09 23:59:09 +0000
@@ -29,6 +29,8 @@
 #include <std/RefBase.h>
 #include <std/String8.h>
 
+#include <chrono>
+
 #ifdef HAVE_ANDROID_OS
 class SkMatrix;
 #endif
@@ -274,9 +276,9 @@
 
     inline int32_t getRepeatCount() const { return mRepeatCount; }
 
-    inline nsecs_t getDownTime() const { return mDownTime; }
+    inline std::chrono::nanoseconds getDownTime() const { return mDownTime; }
 
-    inline nsecs_t getEventTime() const { return mEventTime; }
+    inline std::chrono::nanoseconds getEventTime() const { return mEventTime; }
 
     // Return true if this event may have a default action implementation.
     static bool hasDefaultAction(int32_t keyCode);
@@ -295,8 +297,8 @@
             int32_t scanCode,
             int32_t metaState,
             int32_t repeatCount,
-            nsecs_t downTime,
-            nsecs_t eventTime);
+            std::chrono::nanoseconds downTime,
+            std::chrono::nanoseconds eventTime);
     void initialize(const KeyEvent& from);
 
 protected:
@@ -306,8 +308,8 @@
     int32_t mScanCode;
     int32_t mMetaState;
     int32_t mRepeatCount;
-    nsecs_t mDownTime;
-    nsecs_t mEventTime;
+    std::chrono::nanoseconds mDownTime;
+    std::chrono::nanoseconds mEventTime;
 };
 
 /*
@@ -352,9 +354,9 @@
 
     inline float getYPrecision() const { return mYPrecision; }
 
-    inline nsecs_t getDownTime() const { return mDownTime; }
+    inline std::chrono::nanoseconds getDownTime() const { return mDownTime; }
 
-    inline void setDownTime(nsecs_t downTime) { mDownTime = downTime; }
+    inline void setDownTime(std::chrono::nanoseconds downTime) { mDownTime = downTime; }
 
     inline size_t getPointerCount() const { return mPointerProperties.size(); }
 
@@ -370,7 +372,7 @@
         return mPointerProperties[pointerIndex].toolType;
     }
 
-    inline nsecs_t getEventTime() const { return mSampleEventTimes[getHistorySize()]; }
+    inline std::chrono::nanoseconds getEventTime() const { return mSampleEventTimes[getHistorySize()]; }
 
     const PointerCoords* getRawPointerCoords(size_t pointerIndex) const;
 
@@ -424,7 +426,7 @@
 
     inline size_t getHistorySize() const { return mSampleEventTimes.size() - 1; }
 
-    inline nsecs_t getHistoricalEventTime(size_t historicalIndex) const {
+    inline std::chrono::nanoseconds getHistoricalEventTime(size_t historicalIndex) const {
         return mSampleEventTimes[historicalIndex];
     }
 
@@ -505,8 +507,8 @@
             float yOffset,
             float xPrecision,
             float yPrecision,
-            nsecs_t downTime,
-            nsecs_t eventTime,
+            std::chrono::nanoseconds downTime,
+            std::chrono::nanoseconds eventTime,
             size_t pointerCount,
             const PointerProperties* pointerProperties,
             const PointerCoords* pointerCoords);
@@ -514,7 +516,7 @@
     void copyFrom(const MotionEvent* other, bool keepHistory);
 
     void addSample(
-            nsecs_t eventTime,
+            std::chrono::nanoseconds eventTime,
             const PointerCoords* pointerCoords);
 
     void offsetLocation(float xOffset, float yOffset);
@@ -537,7 +539,7 @@
     inline const PointerProperties* getPointerProperties() const {
         return mPointerProperties.array();
     }
-    inline const nsecs_t* getSampleEventTimes() const { return mSampleEventTimes.array(); }
+    inline const std::chrono::nanoseconds* getSampleEventTimes() const { return mSampleEventTimes.array(); }
     inline const PointerCoords* getSamplePointerCoords() const {
             return mSamplePointerCoords.array();
     }
@@ -552,9 +554,9 @@
     float mYOffset;
     float mXPrecision;
     float mYPrecision;
-    nsecs_t mDownTime;
+    std::chrono::nanoseconds mDownTime;
     Vector<PointerProperties> mPointerProperties;
-    Vector<nsecs_t> mSampleEventTimes;
+    Vector<std::chrono::nanoseconds> mSampleEventTimes;
     Vector<PointerCoords> mSamplePointerCoords;
 };
 

=== modified file '3rd_party/android-input/android/frameworks/base/include/androidfw/InputTransport.h'
--- 3rd_party/android-input/android/frameworks/base/include/androidfw/InputTransport.h	2014-03-06 06:05:17 +0000
+++ 3rd_party/android-input/android/frameworks/base/include/androidfw/InputTransport.h	2015-02-09 23:59:09 +0000
@@ -61,7 +61,7 @@
     union Body {
         struct Key {
             uint32_t seq;
-            nsecs_t eventTime;
+            int64_t eventTime;
             int32_t deviceId;
             int32_t source;
             int32_t action;
@@ -70,7 +70,7 @@
             int32_t scanCode;
             int32_t metaState;
             int32_t repeatCount;
-            nsecs_t downTime;
+            int64_t downTime;
 
             inline size_t size() const {
                 return sizeof(Key);
@@ -79,7 +79,7 @@
 
         struct Motion {
             uint32_t seq;
-            nsecs_t eventTime;
+            int64_t eventTime;
             int32_t deviceId;
             int32_t source;
             int32_t action;
@@ -87,7 +87,7 @@
             int32_t metaState;
             int32_t buttonState;
             int32_t edgeFlags;
-            nsecs_t downTime;
+            int64_t downTime;
             float xOffset;
             float yOffset;
             float xPrecision;
@@ -210,8 +210,8 @@
             int32_t scanCode,
             int32_t metaState,
             int32_t repeatCount,
-            nsecs_t downTime,
-            nsecs_t eventTime);
+            std::chrono::nanoseconds downTime,
+            std::chrono::nanoseconds eventTime);
 
     /* Publishes a motion event to the input channel.
      *
@@ -234,8 +234,8 @@
             float yOffset,
             float xPrecision,
             float yPrecision,
-            nsecs_t downTime,
-            nsecs_t eventTime,
+            std::chrono::nanoseconds downTime,
+            std::chrono::nanoseconds eventTime,
             size_t pointerCount,
             const PointerProperties* pointerProperties,
             const PointerCoords* pointerCoords);
@@ -295,7 +295,7 @@
      * Other errors probably indicate that the channel is broken.
      */
     status_t consume(InputEventFactoryInterface* factory, bool consumeBatches,
-            nsecs_t frameTime, uint32_t* outSeq, InputEvent** outEvent);
+            std::chrono::nanoseconds frameTime, uint32_t* outSeq, InputEvent** outEvent);
 
     /* Sends a finished signal to the publisher to inform it that the message
      * with the specified sequence number has finished being process and whether
@@ -354,13 +354,13 @@
 
     // Touch state per device and source, only for sources of class pointer.
     struct History {
-        nsecs_t eventTime;
+        std::chrono::nanoseconds eventTime;
         IntSet ids;
         std::unordered_map<int32_t, size_t> idToIndex;
         PointerCoords pointers[MAX_POINTERS];
 
         void initializeFrom(const InputMessage* msg) {
-            eventTime = msg->body.motion.eventTime;
+            eventTime = std::chrono::nanoseconds(msg->body.motion.eventTime);
             ids.clear();
             for (size_t i = 0; i < msg->body.motion.pointerCount; i++) {
                 uint32_t id = msg->body.motion.pointers[i].properties.id;
@@ -387,7 +387,7 @@
             this->source = source;
             historyCurrent = 0;
             historySize = 0;
-            lastResample.eventTime = 0;
+            lastResample.eventTime = std::chrono::nanoseconds(0);
             lastResample.ids.clear();
         }
 
@@ -416,13 +416,13 @@
     Vector<SeqChain> mSeqChains;
 
     status_t consumeBatch(InputEventFactoryInterface* factory,
-            nsecs_t frameTime, uint32_t* outSeq, InputEvent** outEvent);
+            std::chrono::nanoseconds frameTime, uint32_t* outSeq, InputEvent** outEvent);
     status_t consumeSamples(InputEventFactoryInterface* factory,
             Batch& batch, size_t count, uint32_t* outSeq, InputEvent** outEvent);
 
     void updateTouchState(InputMessage* msg);
     void rewriteMessage(const TouchState& state, InputMessage* msg);
-    void resampleTouchState(nsecs_t frameTime, MotionEvent* event,
+    void resampleTouchState(std::chrono::nanoseconds frameTime, MotionEvent* event,
             const InputMessage *next);
 
     ssize_t findBatch(int32_t deviceId, int32_t source) const;
@@ -434,7 +434,7 @@
     static void initializeMotionEvent(MotionEvent* event, const InputMessage* msg);
     static void addSample(MotionEvent* event, const InputMessage* msg);
     static bool canAddSample(const Batch& batch, const InputMessage* msg);
-    static ssize_t findSampleNoLaterThan(const Batch& batch, nsecs_t time);
+    static ssize_t findSampleNoLaterThan(const Batch& batch, std::chrono::nanoseconds time);
     static bool shouldResampleTool(int32_t toolType);
 
     static bool isTouchResamplingEnabled();

=== modified file '3rd_party/android-input/android/frameworks/base/include/androidfw/KeyCharacterMap.h'
--- 3rd_party/android-input/android/frameworks/base/include/androidfw/KeyCharacterMap.h	2013-05-03 16:38:07 +0000
+++ 3rd_party/android-input/android/frameworks/base/include/androidfw/KeyCharacterMap.h	2015-02-09 23:59:09 +0000
@@ -230,22 +230,22 @@
     static status_t load(Tokenizer* tokenizer, Format format, sp<KeyCharacterMap>* outMap);
 
     static void addKey(Vector<KeyEvent>& outEvents,
-            int32_t deviceId, int32_t keyCode, int32_t metaState, bool down, nsecs_t time);
+            int32_t deviceId, int32_t keyCode, int32_t metaState, bool down, std::chrono::nanoseconds time);
     static void addMetaKeys(Vector<KeyEvent>& outEvents,
-            int32_t deviceId, int32_t metaState, bool down, nsecs_t time,
+            int32_t deviceId, int32_t metaState, bool down, std::chrono::nanoseconds time,
             int32_t* currentMetaState);
     static bool addSingleEphemeralMetaKey(Vector<KeyEvent>& outEvents,
-            int32_t deviceId, int32_t metaState, bool down, nsecs_t time,
+            int32_t deviceId, int32_t metaState, bool down, std::chrono::nanoseconds time,
             int32_t keyCode, int32_t keyMetaState,
             int32_t* currentMetaState);
     static void addDoubleEphemeralMetaKey(Vector<KeyEvent>& outEvents,
-            int32_t deviceId, int32_t metaState, bool down, nsecs_t time,
+            int32_t deviceId, int32_t metaState, bool down, std::chrono::nanoseconds time,
             int32_t leftKeyCode, int32_t leftKeyMetaState,
             int32_t rightKeyCode, int32_t rightKeyMetaState,
             int32_t eitherKeyMetaState,
             int32_t* currentMetaState);
     static void addLockedMetaKey(Vector<KeyEvent>& outEvents,
-            int32_t deviceId, int32_t metaState, nsecs_t time,
+            int32_t deviceId, int32_t metaState, std::chrono::nanoseconds time,
             int32_t keyCode, int32_t keyMetaState,
             int32_t* currentMetaState);
 };

=== modified file '3rd_party/android-input/android/frameworks/base/include/androidfw/VelocityControl.h'
--- 3rd_party/android-input/android/frameworks/base/include/androidfw/VelocityControl.h	2014-03-06 06:05:17 +0000
+++ 3rd_party/android-input/android/frameworks/base/include/androidfw/VelocityControl.h	2015-02-09 23:59:09 +0000
@@ -90,16 +90,16 @@
 
     /* Translates a raw movement delta into an appropriately
      * scaled / accelerated delta based on the current velocity. */
-    void move(nsecs_t eventTime, float* deltaX, float* deltaY);
+    void move(std::chrono::nanoseconds eventTime, float* deltaX, float* deltaY);
 
 private:
     // If no movements are received within this amount of time,
     // we assume the movement has stopped and reset the movement counters.
-    static const nsecs_t STOP_TIME = 500 * 1000000; // 500 ms
+    static constexpr const std::chrono::nanoseconds STOP_TIME = std::chrono::nanoseconds(500 * 1000000); // 500 ms
 
     VelocityControlParameters mParameters;
 
-    nsecs_t mLastMovementTime;
+    std::chrono::nanoseconds mLastMovementTime;
     VelocityTracker::Position mRawPosition;
     VelocityTracker mVelocityTracker;
     IntSet mIds;

=== modified file '3rd_party/android-input/android/frameworks/base/include/androidfw/VelocityTracker.h'
--- 3rd_party/android-input/android/frameworks/base/include/androidfw/VelocityTracker.h	2014-03-06 06:05:17 +0000
+++ 3rd_party/android-input/android/frameworks/base/include/androidfw/VelocityTracker.h	2015-02-09 23:59:09 +0000
@@ -41,7 +41,7 @@
         static const size_t MAX_DEGREE = 4;
 
         // Estimator time base.
-        nsecs_t time;
+        std::chrono::nanoseconds time;
 
         // Polynomial coefficients describing motion in X and Y.
         float xCoeff[MAX_DEGREE + 1], yCoeff[MAX_DEGREE + 1];
@@ -54,7 +54,7 @@
         float confidence;
 
         inline void clear() {
-            time = 0;
+            time = std::chrono::nanoseconds(0);
             degree = 0;
             confidence = 0;
             for (size_t i = 0; i <= MAX_DEGREE; i++) {
@@ -83,7 +83,7 @@
     // 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 size of ids.
-    void addMovement(nsecs_t eventTime, const IntSet &ids, const Position* positions);
+    void addMovement(std::chrono::nanoseconds eventTime, const IntSet &ids, const Position* positions);
 
     // Adds movement information for all pointers in a MotionEvent, including historical samples.
     void addMovement(const MotionEvent* event);
@@ -107,7 +107,7 @@
 private:
     static const char* DEFAULT_STRATEGY;
 
-    nsecs_t mLastEventTime;
+    std::chrono::nanoseconds mLastEventTime;
     IntSet mCurrentPointerIds;
     int32_t mActivePointerId;
     VelocityTrackerStrategy* mStrategy;
@@ -130,7 +130,7 @@
 
     virtual void clear() = 0;
     virtual void clearPointers(const IntSet &ids) = 0;
-    virtual void addMovement(nsecs_t eventTime, const IntSet &ids,
+    virtual void addMovement(std::chrono::nanoseconds eventTime, const IntSet &ids,
             const VelocityTracker::Position* positions) = 0;
     virtual bool getEstimator(uint32_t id, VelocityTracker::Estimator* outEstimator) const = 0;
 };
@@ -162,7 +162,7 @@
 
     virtual void clear();
     virtual void clearPointers(const IntSet &ids);
-    virtual void addMovement(nsecs_t eventTime, const IntSet &ids,
+    virtual void addMovement(std::chrono::nanoseconds eventTime, const IntSet &ids,
             const VelocityTracker::Position* positions);
     virtual bool getEstimator(uint32_t id, VelocityTracker::Estimator* outEstimator) const;
 
@@ -170,13 +170,13 @@
     // Sample horizon.
     // We don't use too much history by default since we want to react to quick
     // changes in direction.
-    static const nsecs_t HORIZON = 100 * 1000000; // 100 ms
+    static constexpr const std::chrono::nanoseconds HORIZON = std::chrono::nanoseconds(100 * 1000000); // 100 ms
 
     // Number of samples to keep.
     static const uint32_t HISTORY_SIZE = 20;
 
     struct Movement {
-        nsecs_t eventTime;
+        std::chrono::nanoseconds eventTime;
         IntSet ids;
         VelocityTracker::Position positions[MAX_POINTERS];
 
@@ -205,14 +205,14 @@
 
     virtual void clear();
     virtual void clearPointers(const IntSet &ids);
-    virtual void addMovement(nsecs_t eventTime, const IntSet &ids,
+    virtual void addMovement(std::chrono::nanoseconds eventTime, const IntSet &ids,
             const VelocityTracker::Position* positions);
     virtual bool getEstimator(uint32_t id, VelocityTracker::Estimator* outEstimator) const;
 
 private:
     // Current state estimate for a particular pointer.
     struct State {
-        nsecs_t updateTime;
+        std::chrono::nanoseconds updateTime;
         uint32_t degree;
 
         float xpos, xvel, xaccel;
@@ -223,8 +223,8 @@
     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;
+    void initState(State& state, std::chrono::nanoseconds eventTime, float xpos, float ypos) const;
+    void updateState(State& state, std::chrono::nanoseconds eventTime, float xpos, float ypos) const;
     void populateEstimator(const State& state, VelocityTracker::Estimator* outEstimator) const;
 };
 
@@ -239,22 +239,22 @@
 
     virtual void clear();
     virtual void clearPointers(const IntSet &ids);
-    virtual void addMovement(nsecs_t eventTime, const IntSet &ids,
+    virtual void addMovement(std::chrono::nanoseconds eventTime, const IntSet &ids,
             const VelocityTracker::Position* positions);
     virtual bool getEstimator(uint32_t id, VelocityTracker::Estimator* outEstimator) const;
 
 private:
     // Oldest sample to consider when calculating the velocity.
-    static const nsecs_t HORIZON = 200 * 1000000; // 100 ms
+    static constexpr const std::chrono::nanoseconds HORIZON = std::chrono::nanoseconds(200 * 1000000); // 100 ms
 
     // Number of samples to keep.
     static const uint32_t HISTORY_SIZE = 20;
 
     // The minimum duration between samples when estimating velocity.
-    static const nsecs_t MIN_DURATION = 10 * 1000000; // 10 ms
+    static constexpr const std::chrono::nanoseconds MIN_DURATION = std::chrono::nanoseconds(10 * 1000000); // 10 ms
 
     struct Movement {
-        nsecs_t eventTime;
+        std::chrono::nanoseconds eventTime;
         IntSet ids;
         VelocityTracker::Position positions[MAX_POINTERS];
 

=== modified file '3rd_party/android-input/android/frameworks/base/services/input/EventHub.cpp'
--- 3rd_party/android-input/android/frameworks/base/services/input/EventHub.cpp	2014-11-24 03:09:00 +0000
+++ 3rd_party/android-input/android/frameworks/base/services/input/EventHub.cpp	2015-02-09 23:59:09 +0000
@@ -580,7 +580,7 @@
     return false;
 }
 
-void EventHub::vibrate(int32_t deviceId, nsecs_t duration) {
+void EventHub::vibrate(int32_t deviceId, std::chrono::nanoseconds duration) {
     AutoMutex _l(mLock);
     Device* device = getDeviceLocked(deviceId);
     if (device && !device->isVirtual()) {
@@ -590,7 +590,7 @@
         effect.id = device->ffEffectId;
         effect.u.rumble.strong_magnitude = 0xc000;
         effect.u.rumble.weak_magnitude = 0xc000;
-        effect.replay.length = (duration + 999999LL) / 1000000LL;
+        effect.replay.length = (duration + std::chrono::nanoseconds(999999)) / std::chrono::nanoseconds(1000000LL);
         effect.replay.delay = 0;
         if (ioctl(device->fd, EVIOCSFF, &effect)) {
             ALOGW("Could not upload force feedback effect to device %s due to error %d.",
@@ -665,7 +665,7 @@
     size_t capacity = bufferSize;
     bool awoken = false;
     for (;;) {
-        nsecs_t now = systemTime(SYSTEM_TIME_MONOTONIC);
+        std::chrono::nanoseconds now = systemTime(SYSTEM_TIME_MONOTONIC);
 
         // Reopen input devices if needed.
         if (mNeedToReopenDevices) {
@@ -802,8 +802,8 @@
                         // The systemTime(SYSTEM_TIME_MONOTONIC) function we use everywhere
                         // calls clock_gettime(CLOCK_MONOTONIC) which is implemented as a
                         // system call that also queries ktime_get_ts().
-                        event->when = nsecs_t(iev.time.tv_sec) * 1000000000LL
-                                + nsecs_t(iev.time.tv_usec) * 1000LL;
+                        event->when = std::chrono::nanoseconds(iev.time.tv_sec) * 1000000000LL
+                                + std::chrono::nanoseconds(iev.time.tv_usec) * 1000LL;
                         ALOGV("event time %lld, now %lld", event->when, now);
 #else
                         event->when = now;
@@ -813,7 +813,7 @@
                         event->code = iev.code;
                         event->value = iev.value;
 
-                        input_report->received_event_from_kernel(event->when, event->type, event->code, event->value);
+                        input_report->received_event_from_kernel(event->when.count(), event->type, event->code, event->value);
 
                         event += 1;
                     }

=== modified file '3rd_party/android-input/android/frameworks/base/services/input/EventHub.h'
--- 3rd_party/android-input/android/frameworks/base/services/input/EventHub.h	2014-12-08 04:03:47 +0000
+++ 3rd_party/android-input/android/frameworks/base/services/input/EventHub.h	2015-02-09 23:59:09 +0000
@@ -64,7 +64,7 @@
  * A raw event as retrieved from the EventHub.
  */
 struct RawEvent {
-    nsecs_t when;
+    std::chrono::nanoseconds when;
     int32_t deviceId;
     int32_t type;
     int32_t code;
@@ -233,7 +233,7 @@
     virtual bool setKeyboardLayoutOverlay(int32_t deviceId, const sp<KeyCharacterMap>& map) = 0;
 
     /* Control the vibrator. */
-    virtual void vibrate(int32_t deviceId, nsecs_t duration) = 0;
+    virtual void vibrate(int32_t deviceId, std::chrono::nanoseconds duration) = 0;
     virtual void cancelVibrate(int32_t deviceId) = 0;
 
     /* Requests the EventHub to reopen all input devices on the next call to getEvents(). */
@@ -298,7 +298,7 @@
     virtual sp<KeyCharacterMap> getKeyCharacterMap(int32_t deviceId) const;
     virtual bool setKeyboardLayoutOverlay(int32_t deviceId, const sp<KeyCharacterMap>& map);
 
-    virtual void vibrate(int32_t deviceId, nsecs_t duration);
+    virtual void vibrate(int32_t deviceId, std::chrono::nanoseconds duration);
     virtual void cancelVibrate(int32_t deviceId);
 
     virtual void requestReopenDevices();

=== modified file '3rd_party/android-input/android/frameworks/base/services/input/Input.cpp'
--- 3rd_party/android-input/android/frameworks/base/services/input/Input.cpp	2013-05-03 16:38:07 +0000
+++ 3rd_party/android-input/android/frameworks/base/services/input/Input.cpp	2015-02-09 23:59:09 +0000
@@ -130,8 +130,8 @@
         int32_t scanCode,
         int32_t metaState,
         int32_t repeatCount,
-        nsecs_t downTime,
-        nsecs_t eventTime) {
+        std::chrono::nanoseconds downTime,
+        std::chrono::nanoseconds eventTime) {
     InputEvent::initialize(deviceId, source);
     mAction = action;
     mFlags = flags;
@@ -294,8 +294,8 @@
         float yOffset,
         float xPrecision,
         float yPrecision,
-        nsecs_t downTime,
-        nsecs_t eventTime,
+        std::chrono::nanoseconds downTime,
+        std::chrono::nanoseconds eventTime,
         size_t pointerCount,
         const PointerProperties* pointerProperties,
         const PointerCoords* pointerCoords) {
@@ -346,7 +346,7 @@
 }
 
 void MotionEvent::addSample(
-        int64_t eventTime,
+        std::chrono::nanoseconds eventTime,
         const PointerCoords* pointerCoords) {
     mSampleEventTimes.push(eventTime);
     mSamplePointerCoords.appendArray(pointerCoords, getPointerCount());

=== modified file '3rd_party/android-input/android/frameworks/base/services/input/InputApplication.h'
--- 3rd_party/android-input/android/frameworks/base/services/input/InputApplication.h	2013-05-03 16:38:07 +0000
+++ 3rd_party/android-input/android/frameworks/base/services/input/InputApplication.h	2015-02-09 23:59:09 +0000
@@ -30,7 +30,7 @@
  */
 struct InputApplicationInfo {
     String8 name;
-    nsecs_t dispatchingTimeout;
+    std::chrono::nanoseconds dispatchingTimeout;
 };
 
 
@@ -50,7 +50,7 @@
         return mInfo ? mInfo->name : String8("<invalid>");
     }
 
-    inline nsecs_t getDispatchingTimeout(nsecs_t defaultValue) const {
+    inline std::chrono::nanoseconds getDispatchingTimeout(std::chrono::nanoseconds defaultValue) const {
         return mInfo ? mInfo->dispatchingTimeout : defaultValue;
     }
 

=== modified file '3rd_party/android-input/android/frameworks/base/services/input/InputDispatcher.cpp'
--- 3rd_party/android-input/android/frameworks/base/services/input/InputDispatcher.cpp	2014-12-08 04:03:47 +0000
+++ 3rd_party/android-input/android/frameworks/base/services/input/InputDispatcher.cpp	2015-02-09 23:59:09 +0000
@@ -88,7 +88,7 @@
 const nsecs_t SLOW_EVENT_PROCESSING_WARNING_TIMEOUT = 2000 * 1000000LL; // 2sec
 
 
-static inline nsecs_t now() {
+static inline std::chrono::nanoseconds now() {
     return systemTime(SYSTEM_TIME_MONOTONIC);
 }
 
@@ -203,7 +203,7 @@
 }
 
 void InputDispatcher::dispatchOnce() {
-    nsecs_t nextWakeupTime = LONG_LONG_MAX;
+    std::chrono::nanoseconds nextWakeupTime(LONG_LONG_MAX);
     { // acquire lock
         AutoMutex _l(mLock);
         broadcast(mDispatcherIsAliveCondition);
@@ -211,18 +211,18 @@
         dispatchOnceInnerLocked(&nextWakeupTime);
 
         if (runCommandsLockedInterruptible()) {
-            nextWakeupTime = LONG_LONG_MIN;  // force next poll to wake up immediately
+            nextWakeupTime = std::chrono::nanoseconds(0);
         }
     } // release lock
 
     // Wait for callback or timeout or wake.  (make sure we round up, not down)
-    nsecs_t currentTime = now();
+    std::chrono::nanoseconds currentTime = now();
     int timeoutMillis = toMillisecondTimeoutDelay(currentTime, nextWakeupTime);
     mLooper->pollOnce(timeoutMillis);
 }
 
-void InputDispatcher::dispatchOnceInnerLocked(nsecs_t* nextWakeupTime) {
-    nsecs_t currentTime = now();
+void InputDispatcher::dispatchOnceInnerLocked(std::chrono::nanoseconds* nextWakeupTime) {
+    std::chrono::nanoseconds currentTime = now();
 
     // Reset the key repeat timer whenever we disallow key events, even if the next event
     // is not a key.  This is to ensure that we abort a key repeat if the device is just coming
@@ -363,7 +363,7 @@
         }
 
         releasePendingEventLocked();
-        *nextWakeupTime = LONG_LONG_MIN;  // force next poll to wake up immediately
+        *nextWakeupTime = std::chrono::nanoseconds(LONG_LONG_MIN);  // force next poll to wake up immediately
     }
 }
 
@@ -385,7 +385,7 @@
 #if DEBUG_APP_SWITCH
                     ALOGD("App switch is pending!");
 #endif
-                    mAppSwitchDueTime = keyEntry->eventTime + APP_SWITCH_TIMEOUT;
+                    mAppSwitchDueTime = keyEntry->eventTime + std::chrono::nanoseconds(APP_SWITCH_TIMEOUT);
                     mAppSwitchSawKeyDown = false;
                     needWake = true;
                 }
@@ -515,11 +515,11 @@
 }
 
 bool InputDispatcher::isAppSwitchPendingLocked() {
-    return mAppSwitchDueTime != LONG_LONG_MAX;
+    return mAppSwitchDueTime != std::chrono::nanoseconds(LONG_LONG_MAX);
 }
 
 void InputDispatcher::resetPendingAppSwitchLocked(bool handled) {
-    mAppSwitchDueTime = LONG_LONG_MAX;
+    mAppSwitchDueTime = std::chrono::nanoseconds(LONG_LONG_MAX);
 
 #if DEBUG_APP_SWITCH
     if (handled) {
@@ -530,8 +530,8 @@
 #endif
 }
 
-bool InputDispatcher::isStaleEventLocked(nsecs_t currentTime, EventEntry* entry) {
-    return currentTime - entry->eventTime >= STALE_EVENT_TIMEOUT;
+bool InputDispatcher::isStaleEventLocked(std::chrono::nanoseconds currentTime, EventEntry* entry) {
+    return currentTime - entry->eventTime >= std::chrono::nanoseconds(STALE_EVENT_TIMEOUT);
 }
 
 bool InputDispatcher::runCommandsLockedInterruptible() {
@@ -593,7 +593,7 @@
     }
 }
 
-InputDispatcher::KeyEntry* InputDispatcher::synthesizeKeyRepeatLocked(nsecs_t currentTime) {
+InputDispatcher::KeyEntry* InputDispatcher::synthesizeKeyRepeatLocked(std::chrono::nanoseconds currentTime) {
     KeyEntry* entry = mKeyRepeatState.lastKeyEntry;
 
     // Reuse the repeated key entry if it is otherwise unreferenced.
@@ -626,7 +626,7 @@
 }
 
 bool InputDispatcher::dispatchConfigurationChangedLocked(
-        nsecs_t currentTime, ConfigurationChangedEntry* entry) {
+        std::chrono::nanoseconds currentTime, ConfigurationChangedEntry* entry) {
 #if DEBUG_OUTBOUND_EVENT_DETAILS
     ALOGD("dispatchConfigurationChanged - eventTime=%lld", entry->eventTime);
 #endif
@@ -642,7 +642,7 @@
 }
 
 bool InputDispatcher::dispatchDeviceResetLocked(
-        nsecs_t currentTime, DeviceResetEntry* entry) {
+        std::chrono::nanoseconds currentTime, DeviceResetEntry* entry) {
 #if DEBUG_OUTBOUND_EVENT_DETAILS
     ALOGD("dispatchDeviceReset - eventTime=%lld, deviceId=%d", entry->eventTime, entry->deviceId);
 #endif
@@ -654,8 +654,8 @@
     return true;
 }
 
-bool InputDispatcher::dispatchKeyLocked(nsecs_t currentTime, KeyEntry* entry,
-        DropReason* dropReason, nsecs_t* nextWakeupTime) {
+bool InputDispatcher::dispatchKeyLocked(std::chrono::nanoseconds currentTime, KeyEntry* entry,
+        DropReason* dropReason, std::chrono::nanoseconds* nextWakeupTime) {
     // Preprocessing.
     if (! entry->dispatchInProgress) {
         if (entry->repeatCount == 0
@@ -670,7 +670,7 @@
                 // we will not need to synthesize key repeats ourselves.
                 entry->repeatCount = mKeyRepeatState.lastKeyEntry->repeatCount + 1;
                 resetKeyRepeatLocked();
-                mKeyRepeatState.nextRepeatTime = LONG_LONG_MAX; // don't generate repeats ourselves
+                mKeyRepeatState.nextRepeatTime = std::chrono::nanoseconds(LONG_LONG_MAX); // don't generate repeats ourselves
             } else {
                 // Not a repeat.  Save key down state in case we do see a repeat later.
                 resetKeyRepeatLocked();
@@ -702,7 +702,7 @@
             return false; // wait until next wakeup
         }
         entry->interceptKeyResult = KeyEntry::INTERCEPT_KEY_RESULT_UNKNOWN;
-        entry->interceptKeyWakeupTime = 0;
+        entry->interceptKeyWakeupTime = std::chrono::nanoseconds(0);
     }
 
     // Give the policy a chance to intercept the key.
@@ -765,7 +765,7 @@
 }
 
 bool InputDispatcher::dispatchMotionLocked(
-        nsecs_t currentTime, MotionEntry* entry, DropReason* dropReason, nsecs_t* nextWakeupTime) {
+        std::chrono::nanoseconds currentTime, MotionEntry* entry, DropReason* dropReason, std::chrono::nanoseconds* nextWakeupTime) {
     // Preprocessing.
     if (! entry->dispatchInProgress) {
         entry->dispatchInProgress = true;
@@ -851,7 +851,7 @@
 #endif
 }
 
-void InputDispatcher::dispatchEventLocked(nsecs_t currentTime,
+void InputDispatcher::dispatchEventLocked(std::chrono::nanoseconds currentTime,
         EventEntry* eventEntry, const Vector<InputTarget>& inputTargets) {
 #if DEBUG_DISPATCH_CYCLE
     ALOGD("dispatchEventToCurrentInputTargets");
@@ -876,11 +876,11 @@
     }
 }
 
-int32_t InputDispatcher::handleTargetsNotReadyLocked(nsecs_t currentTime,
+int32_t InputDispatcher::handleTargetsNotReadyLocked(std::chrono::nanoseconds currentTime,
         const EventEntry* entry,
         const sp<InputApplicationHandle>& applicationHandle,
         const sp<InputWindowHandle>& windowHandle,
-        nsecs_t* nextWakeupTime, const char* reason) {
+        std::chrono::nanoseconds* nextWakeupTime, const char* reason) {
     if (applicationHandle == NULL && windowHandle == NULL) {
         if (mInputTargetWaitCause != INPUT_TARGET_WAIT_CAUSE_SYSTEM_NOT_READY) {
 #if DEBUG_FOCUS
@@ -888,7 +888,7 @@
 #endif
             mInputTargetWaitCause = INPUT_TARGET_WAIT_CAUSE_SYSTEM_NOT_READY;
             mInputTargetWaitStartTime = currentTime;
-            mInputTargetWaitTimeoutTime = LONG_LONG_MAX;
+            mInputTargetWaitTimeoutTime = std::chrono::nanoseconds(LONG_LONG_MAX);
             mInputTargetWaitTimeoutExpired = false;
             mInputTargetWaitApplicationHandle.clear();
         }
@@ -899,14 +899,14 @@
                 c_str(getApplicationWindowLabelLocked(applicationHandle, windowHandle)),
                     reason);
 #endif
-            nsecs_t timeout;
+            std::chrono::nanoseconds timeout;
             if (windowHandle != NULL) {
-                timeout = windowHandle->getDispatchingTimeout(DEFAULT_INPUT_DISPATCHING_TIMEOUT);
+                timeout = windowHandle->getDispatchingTimeout(std::chrono::nanoseconds(DEFAULT_INPUT_DISPATCHING_TIMEOUT));
             } else if (applicationHandle != NULL) {
                 timeout = applicationHandle->getDispatchingTimeout(
-                        DEFAULT_INPUT_DISPATCHING_TIMEOUT);
+                    std::chrono::nanoseconds(DEFAULT_INPUT_DISPATCHING_TIMEOUT));
             } else {
-                timeout = DEFAULT_INPUT_DISPATCHING_TIMEOUT;
+                timeout = std::chrono::nanoseconds(DEFAULT_INPUT_DISPATCHING_TIMEOUT);
             }
 
             mInputTargetWaitCause = INPUT_TARGET_WAIT_CAUSE_APPLICATION_NOT_READY;
@@ -934,7 +934,7 @@
 
         // Force poll loop to wake up immediately on next iteration once we get the
         // ANR response back from the policy.
-        *nextWakeupTime = LONG_LONG_MIN;
+        *nextWakeupTime = std::chrono::nanoseconds(LONG_LONG_MIN);
         return INPUT_EVENT_INJECTION_PENDING;
     } else {
         // Force poll loop to wake up when timeout is due.
@@ -945,9 +945,9 @@
     }
 }
 
-void InputDispatcher::resumeAfterTargetsNotReadyTimeoutLocked(nsecs_t newTimeout,
+void InputDispatcher::resumeAfterTargetsNotReadyTimeoutLocked(std::chrono::nanoseconds newTimeout,
         const sp<InputChannel>& inputChannel) {
-    if (newTimeout > 0) {
+    if (newTimeout > std::chrono::nanoseconds(0)) {
         // Extend the timeout.
         mInputTargetWaitTimeoutTime = now() + newTimeout;
     } else {
@@ -975,12 +975,12 @@
     }
 }
 
-nsecs_t InputDispatcher::getTimeSpentWaitingForApplicationLocked(
-        nsecs_t currentTime) {
+std::chrono::nanoseconds InputDispatcher::getTimeSpentWaitingForApplicationLocked(
+        std::chrono::nanoseconds currentTime) {
     if (mInputTargetWaitCause == INPUT_TARGET_WAIT_CAUSE_APPLICATION_NOT_READY) {
         return currentTime - mInputTargetWaitStartTime;
     }
-    return 0;
+    return std::chrono::nanoseconds(0);
 }
 
 void InputDispatcher::resetANRTimeoutsLocked() {
@@ -993,8 +993,8 @@
     mInputTargetWaitApplicationHandle.clear();
 }
 
-int32_t InputDispatcher::findFocusedWindowTargetsLocked(nsecs_t currentTime,
-        const EventEntry* entry, Vector<InputTarget>& inputTargets, nsecs_t* nextWakeupTime) {
+int32_t InputDispatcher::findFocusedWindowTargetsLocked(std::chrono::nanoseconds currentTime,
+        const EventEntry* entry, Vector<InputTarget>& inputTargets, std::chrono::nanoseconds* nextWakeupTime) {
     int32_t injectionResult;
 
     // If there is no currently focused window and no focused application
@@ -1046,7 +1046,7 @@
     // Done.
 Failed:
 Unresponsive:
-    nsecs_t timeSpentWaitingForApplication = getTimeSpentWaitingForApplicationLocked(currentTime);
+    std::chrono::nanoseconds timeSpentWaitingForApplication = getTimeSpentWaitingForApplicationLocked(currentTime);
     updateDispatchStatisticsLocked(currentTime, entry,
             injectionResult, timeSpentWaitingForApplication);
 #if DEBUG_FOCUS
@@ -1057,8 +1057,8 @@
     return injectionResult;
 }
 
-int32_t InputDispatcher::findTouchedWindowTargetsLocked(nsecs_t currentTime,
-        const MotionEntry* entry, Vector<InputTarget>& inputTargets, nsecs_t* nextWakeupTime,
+int32_t InputDispatcher::findTouchedWindowTargetsLocked(std::chrono::nanoseconds currentTime,
+        const MotionEntry* entry, Vector<InputTarget>& inputTargets, std::chrono::nanoseconds* nextWakeupTime,
         bool* outConflictingPointerActions) {
     enum InjectionPermission {
         INJECTION_PERMISSION_UNKNOWN,
@@ -1066,7 +1066,7 @@
         INJECTION_PERMISSION_DENIED
     };
 
-    nsecs_t startTime = now();
+    std::chrono::nanoseconds startTime = now();
 
     // For security reasons, we defer updating the touch state until we are sure that
     // event injection will be allowed.
@@ -1524,7 +1524,7 @@
     // Reset temporary touch state to ensure we release unnecessary references to input channels.
     mTempTouchState.reset();
 
-    nsecs_t timeSpentWaitingForApplication = getTimeSpentWaitingForApplicationLocked(currentTime);
+    std::chrono::nanoseconds timeSpentWaitingForApplication = getTimeSpentWaitingForApplicationLocked(currentTime);
     updateDispatchStatisticsLocked(currentTime, entry,
             injectionResult, timeSpentWaitingForApplication);
 #if DEBUG_FOCUS
@@ -1622,7 +1622,7 @@
     return obscured;
 }
 
-bool InputDispatcher::isWindowReadyForMoreInputLocked(nsecs_t currentTime,
+bool InputDispatcher::isWindowReadyForMoreInputLocked(std::chrono::nanoseconds currentTime,
         const sp<InputWindowHandle>& windowHandle, const EventEntry* eventEntry) {
     ssize_t connectionIndex = getConnectionIndexLocked(windowHandle->getInputChannel());
     if (connectionIndex >= 0) {
@@ -1662,7 +1662,7 @@
         // This condition ensures that ANRs are detected reliably.
         if (!connection->waitQueue.isEmpty()
                 && currentTime >= connection->waitQueue.head->eventEntry->eventTime
-                        + STREAM_AHEAD_EVENT_TIMEOUT) {
+            + std::chrono::nanoseconds(STREAM_AHEAD_EVENT_TIMEOUT)) {
             return false;
         }
     }
@@ -1688,7 +1688,7 @@
     }
 }
 
-void InputDispatcher::prepareDispatchCycleLocked(nsecs_t currentTime,
+void InputDispatcher::prepareDispatchCycleLocked(std::chrono::nanoseconds currentTime,
         const sp<Connection>& connection, EventEntry* eventEntry, const InputTarget* inputTarget) {
 #if DEBUG_DISPATCH_CYCLE
     std::string pointerIdsString = inputTarget->pointerIds.toString();
@@ -1737,7 +1737,7 @@
     enqueueDispatchEntriesLocked(currentTime, connection, eventEntry, inputTarget);
 }
 
-void InputDispatcher::enqueueDispatchEntriesLocked(nsecs_t currentTime,
+void InputDispatcher::enqueueDispatchEntriesLocked(std::chrono::nanoseconds currentTime,
         const sp<Connection>& connection, EventEntry* eventEntry, const InputTarget* inputTarget) {
     bool wasEmpty = connection->outboundQueue.isEmpty();
 
@@ -1847,7 +1847,7 @@
     connection->outboundQueue.enqueueAtTail(dispatchEntry);
 }
 
-void InputDispatcher::startDispatchCycleLocked(nsecs_t currentTime,
+void InputDispatcher::startDispatchCycleLocked(std::chrono::nanoseconds currentTime,
         const sp<Connection>& connection) {
 #if DEBUG_DISPATCH_CYCLE
     ALOGD("channel '%s' ~ startDispatchCycle",
@@ -1875,7 +1875,7 @@
                     keyEntry->eventTime);
             input_report->published_key_event(connection->inputChannel->getFd(),
                                               dispatchEntry->seq,
-                                              keyEntry->eventTime);
+                                              keyEntry->eventTime.count());
             break;
         }
 
@@ -1925,7 +1925,7 @@
                     usingCoords);
             input_report->published_motion_event(connection->inputChannel->getFd(),
                                                  dispatchEntry->seq,
-                                                 motionEntry->eventTime);
+                                                 motionEntry->eventTime.count());
             break;
         }
 
@@ -1967,7 +1967,7 @@
     }
 }
 
-void InputDispatcher::finishDispatchCycleLocked(nsecs_t currentTime,
+void InputDispatcher::finishDispatchCycleLocked(std::chrono::nanoseconds currentTime,
         const sp<Connection>& connection, uint32_t seq, bool handled) {
 #if DEBUG_DISPATCH_CYCLE
     ALOGD("channel '%s' ~ finishDispatchCycle - seq=%u, handled=%s",
@@ -1985,7 +1985,7 @@
     onDispatchCycleFinishedLocked(currentTime, connection, seq, handled);
 }
 
-void InputDispatcher::abortBrokenDispatchCycleLocked(nsecs_t currentTime,
+void InputDispatcher::abortBrokenDispatchCycleLocked(std::chrono::nanoseconds currentTime,
         const sp<Connection>& connection, bool notify) {
 #if DEBUG_DISPATCH_CYCLE
     ALOGD("channel '%s' ~ abortBrokenDispatchCycle - notify=%s",
@@ -2044,7 +2044,7 @@
                 return 1;
             }
 
-            nsecs_t currentTime = now();
+            std::chrono::nanoseconds currentTime = now();
             bool gotOne = false;
             status_t status;
             for (;;) {
@@ -2110,7 +2110,7 @@
         return;
     }
 
-    nsecs_t currentTime = now();
+    std::chrono::nanoseconds currentTime = now();
 
     Vector<EventEntry*> cancelationEvents;
     connection->inputState.synthesizeCancelationEvents(currentTime,
@@ -2459,7 +2459,8 @@
             event->getType(), injectorPid, injectorUid, syncMode, timeoutMillis, policyFlags);
 #endif
 
-    nsecs_t endTime = now() + milliseconds_to_nanoseconds(timeoutMillis);
+    std::chrono::nanoseconds endTime =
+        now() + std::chrono::duration_cast<std::chrono::nanoseconds>(std::chrono::milliseconds(timeoutMillis));
 
     policyFlags |= POLICY_FLAG_INJECTED;
     if (hasInjectionPermission(injectorPid, injectorUid)) {
@@ -2509,12 +2510,12 @@
         }
 
         if (!(policyFlags & POLICY_FLAG_FILTERED)) {
-            nsecs_t eventTime = motionEvent->getEventTime();
+            std::chrono::nanoseconds eventTime = motionEvent->getEventTime();
             mPolicy->interceptMotionBeforeQueueing(eventTime, /*byref*/ policyFlags);
         }
 
         mLock.lock();
-        const nsecs_t* sampleEventTimes = motionEvent->getSampleEventTimes();
+        const std::chrono::nanoseconds* sampleEventTimes = motionEvent->getSampleEventTimes();
         const PointerCoords* samplePointerCoords = motionEvent->getSamplePointerCoords();
         firstInjectedEntry = new MotionEntry(*sampleEventTimes,
                 motionEvent->getDeviceId(), motionEvent->getSource(), policyFlags,
@@ -2581,8 +2582,8 @@
                     break;
                 }
 
-                nsecs_t remainingTimeout = endTime - now();
-                if (remainingTimeout <= 0) {
+                std::chrono::nanoseconds remainingTimeout = endTime - now();
+                if (remainingTimeout <= std::chrono::nanoseconds(0)) {
 #if DEBUG_INJECTION
                     ALOGD("injectInputEvent - Timed out waiting for injection result "
                             "to become available.");
@@ -2601,8 +2602,8 @@
                     ALOGD("injectInputEvent - Waiting for %d pending foreground dispatches.",
                             injectionState->pendingForegroundDispatches);
 #endif
-                    nsecs_t remainingTimeout = endTime - now();
-                    if (remainingTimeout <= 0) {
+                    std::chrono::nanoseconds remainingTimeout = endTime - now();
+                    if (remainingTimeout <= std::chrono::nanoseconds(0)) {
 #if DEBUG_INJECTION
                     ALOGD("injectInputEvent - Timed out waiting for pending foreground "
                             "dispatches to finish.");
@@ -2990,7 +2991,7 @@
         appendFormat(dump, INDENT "FocusedApplication: name='%s', dispatchingTimeout=%0.3fms\n",
                 c_str(mFocusedApplicationHandle->getName()),
                 mFocusedApplicationHandle->getDispatchingTimeout(
-                        DEFAULT_INPUT_DISPATCHING_TIMEOUT) / 1000000.0);
+                    std::chrono::nanoseconds(DEFAULT_INPUT_DISPATCHING_TIMEOUT)) / 1000000.0);
     } else {
         dump.append(INDENT "FocusedApplication: <null>\n");
     }
@@ -3056,7 +3057,7 @@
         dump.append(INDENT "MonitoringChannels: <none>\n");
     }
 
-    nsecs_t currentTime = now();
+    std::chrono::nanoseconds currentTime = now();
 
     if (!mInboundQueue.isEmpty()) {
         appendFormat(dump, INDENT "InboundQueue: length=%u\n", mInboundQueue.count());
@@ -3200,7 +3201,7 @@
 
     mLooper->removeFd(inputChannel->getFd());
 
-    nsecs_t currentTime = now();
+    std::chrono::nanoseconds currentTime = now();
     abortBrokenDispatchCycleLocked(currentTime, connection, notify);
 
     runCommandsLockedInterruptible();
@@ -3231,7 +3232,7 @@
 }
 
 void InputDispatcher::onDispatchCycleFinishedLocked(
-        nsecs_t currentTime, const sp<Connection>& connection, uint32_t seq, bool handled) {
+        std::chrono::nanoseconds currentTime, const sp<Connection>& connection, uint32_t seq, bool handled) {
     CommandEntry* commandEntry = postCommandLocked(
             & InputDispatcher::doDispatchCycleFinishedLockedInterruptible);
     commandEntry->connection = connection;
@@ -3241,7 +3242,7 @@
 }
 
 void InputDispatcher::onDispatchCycleBrokenLocked(
-        nsecs_t currentTime, const sp<Connection>& connection) {
+        std::chrono::nanoseconds currentTime, const sp<Connection>& connection) {
     ALOGE("channel '%s' ~ Channel is unrecoverably broken and will be disposed!",
             connection->getInputChannelName());
 
@@ -3251,11 +3252,11 @@
 }
 
 void InputDispatcher::onANRLocked(
-        nsecs_t currentTime, const sp<InputApplicationHandle>& applicationHandle,
+        std::chrono::nanoseconds currentTime, const sp<InputApplicationHandle>& applicationHandle,
         const sp<InputWindowHandle>& windowHandle,
-        nsecs_t eventTime, nsecs_t waitStartTime, const char* reason) {
-    float dispatchLatency = (currentTime - eventTime) * 0.000001f;
-    float waitDuration = (currentTime - waitStartTime) * 0.000001f;
+        std::chrono::nanoseconds eventTime, std::chrono::nanoseconds waitStartTime, const char* reason) {
+    float dispatchLatency = (currentTime - eventTime).count() * 0.000001f;
+    float waitDuration = (currentTime - waitStartTime).count() * 0.000001f;
     ALOGI("Application is not responding: %s.  "
             "It has been %0.1fms since event, %0.1fms since wait started.  Reason: %s",
             c_str(getApplicationWindowLabelLocked(applicationHandle, windowHandle)),
@@ -3309,7 +3310,7 @@
         CommandEntry* commandEntry) {
     mLock.unlock();
 
-    nsecs_t newTimeout = mPolicy->notifyANR(
+    std::chrono::nanoseconds newTimeout = mPolicy->notifyANR(
             commandEntry->inputApplicationHandle, commandEntry->inputWindowHandle);
 
     mLock.lock();
@@ -3328,14 +3329,14 @@
 
     mLock.unlock();
 
-    nsecs_t delay = mPolicy->interceptKeyBeforeDispatching(commandEntry->inputWindowHandle,
+    std::chrono::nanoseconds delay = mPolicy->interceptKeyBeforeDispatching(commandEntry->inputWindowHandle,
             &event, entry->policyFlags);
 
     mLock.lock();
 
-    if (delay < 0) {
+    if (delay < std::chrono::nanoseconds(0)) {
         entry->interceptKeyResult = KeyEntry::INTERCEPT_KEY_RESULT_SKIP;
-    } else if (!delay) {
+    } else if (!delay.count()) {
         entry->interceptKeyResult = KeyEntry::INTERCEPT_KEY_RESULT_CONTINUE;
     } else {
         entry->interceptKeyResult = KeyEntry::INTERCEPT_KEY_RESULT_TRY_AGAIN_LATER;
@@ -3347,15 +3348,15 @@
 void InputDispatcher::doDispatchCycleFinishedLockedInterruptible(
         CommandEntry* commandEntry) {
     sp<Connection> connection = commandEntry->connection;
-    nsecs_t finishTime = commandEntry->eventTime;
+    std::chrono::nanoseconds finishTime = commandEntry->eventTime;
     uint32_t seq = commandEntry->seq;
     bool handled = commandEntry->handled;
 
     // Handle post-event policy actions.
     DispatchEntry* dispatchEntry = connection->findWaitQueueEntry(seq);
     if (dispatchEntry) {
-        nsecs_t eventDuration = finishTime - dispatchEntry->deliveryTime;
-        if (eventDuration > SLOW_EVENT_PROCESSING_WARNING_TIMEOUT) {
+        std::chrono::nanoseconds eventDuration = finishTime - dispatchEntry->deliveryTime;
+        if (eventDuration > std::chrono::nanoseconds(SLOW_EVENT_PROCESSING_WARNING_TIMEOUT)) {
             String8 msg;
             appendFormat(msg, "Window '%s' spent %0.1fms processing the last input event: ",
                     connection->getWindowName(), eventDuration * 0.000001f);
@@ -3585,8 +3586,8 @@
             entry->downTime, entry->eventTime);
 }
 
-void InputDispatcher::updateDispatchStatisticsLocked(nsecs_t currentTime, const EventEntry* entry,
-        int32_t injectionResult, nsecs_t timeSpentWaitingForApplication) {
+void InputDispatcher::updateDispatchStatisticsLocked(std::chrono::nanoseconds currentTime, const EventEntry* entry,
+        int32_t injectionResult, std::chrono::nanoseconds timeSpentWaitingForApplication) {
     // TODO Write some statistics about how long we spend waiting.
 }
 
@@ -3646,7 +3647,7 @@
 
 // --- InputDispatcher::EventEntry ---
 
-InputDispatcher::EventEntry::EventEntry(int32_t type, nsecs_t eventTime, uint32_t policyFlags) :
+InputDispatcher::EventEntry::EventEntry(int32_t type, std::chrono::nanoseconds eventTime, uint32_t policyFlags) :
         refCount(1), type(type), eventTime(eventTime), policyFlags(policyFlags),
         injectionState(NULL), dispatchInProgress(false) {
 }
@@ -3674,7 +3675,7 @@
 
 // --- InputDispatcher::ConfigurationChangedEntry ---
 
-InputDispatcher::ConfigurationChangedEntry::ConfigurationChangedEntry(nsecs_t eventTime) :
+InputDispatcher::ConfigurationChangedEntry::ConfigurationChangedEntry(std::chrono::nanoseconds eventTime) :
         EventEntry(TYPE_CONFIGURATION_CHANGED, eventTime, 0) {
 }
 
@@ -3688,7 +3689,7 @@
 
 // --- InputDispatcher::DeviceResetEntry ---
 
-InputDispatcher::DeviceResetEntry::DeviceResetEntry(nsecs_t eventTime, int32_t deviceId) :
+InputDispatcher::DeviceResetEntry::DeviceResetEntry(std::chrono::nanoseconds eventTime, int32_t deviceId) :
         EventEntry(TYPE_DEVICE_RESET, eventTime, 0),
         deviceId(deviceId) {
 }
@@ -3703,10 +3704,10 @@
 
 // --- InputDispatcher::KeyEntry ---
 
-InputDispatcher::KeyEntry::KeyEntry(nsecs_t eventTime,
+InputDispatcher::KeyEntry::KeyEntry(std::chrono::nanoseconds eventTime,
         int32_t deviceId, uint32_t source, uint32_t policyFlags, int32_t action,
         int32_t flags, int32_t keyCode, int32_t scanCode, int32_t metaState,
-        int32_t repeatCount, nsecs_t downTime) :
+        int32_t repeatCount, std::chrono::nanoseconds downTime) :
         EventEntry(TYPE_KEY, eventTime, policyFlags),
         deviceId(deviceId), source(source), action(action), flags(flags),
         keyCode(keyCode), scanCode(scanCode), metaState(metaState),
@@ -3729,17 +3730,17 @@
     dispatchInProgress = false;
     syntheticRepeat = false;
     interceptKeyResult = KeyEntry::INTERCEPT_KEY_RESULT_UNKNOWN;
-    interceptKeyWakeupTime = 0;
+    interceptKeyWakeupTime = std::chrono::nanoseconds(0);
 }
 
 
 // --- InputDispatcher::MotionEntry ---
 
-InputDispatcher::MotionEntry::MotionEntry(nsecs_t eventTime,
+InputDispatcher::MotionEntry::MotionEntry(std::chrono::nanoseconds eventTime,
         int32_t deviceId, uint32_t source, uint32_t policyFlags, int32_t action, int32_t flags,
         int32_t metaState, int32_t buttonState,
         int32_t edgeFlags, float xPrecision, float yPrecision,
-        nsecs_t downTime, uint32_t pointerCount,
+        std::chrono::nanoseconds downTime, uint32_t pointerCount,
         const PointerProperties* pointerProperties, const PointerCoords* pointerCoords) :
         EventEntry(TYPE_MOTION, eventTime, policyFlags),
         eventTime(eventTime),
@@ -4005,7 +4006,7 @@
     }
 }
 
-void InputDispatcher::InputState::synthesizeCancelationEvents(nsecs_t currentTime,
+void InputDispatcher::InputState::synthesizeCancelationEvents(std::chrono::nanoseconds currentTime,
         Vector<EventEntry*>& outEvents, const CancelationOptions& options) {
     for (size_t i = 0; i < mKeyMementos.size(); i++) {
         const KeyMemento& memento = mKeyMementos.itemAt(i);

=== modified file '3rd_party/android-input/android/frameworks/base/services/input/InputDispatcher.h'
--- 3rd_party/android-input/android/frameworks/base/services/input/InputDispatcher.h	2014-12-08 04:03:47 +0000
+++ 3rd_party/android-input/android/frameworks/base/services/input/InputDispatcher.h	2015-02-09 23:59:09 +0000
@@ -180,10 +180,10 @@
  */
 struct InputDispatcherConfiguration {
     // The key repeat initial timeout.
-    nsecs_t keyRepeatTimeout;
+    std::chrono::nanoseconds keyRepeatTimeout;
 
     // The key repeat inter-key delay.
-    nsecs_t keyRepeatDelay;
+    std::chrono::nanoseconds keyRepeatDelay;
 
     InputDispatcherConfiguration() :
             keyRepeatTimeout(500 * 1000000LL),
@@ -207,11 +207,11 @@
 
 public:
     /* Notifies the system that a configuration change has occurred. */
-    virtual void notifyConfigurationChanged(nsecs_t when) = 0;
+    virtual void notifyConfigurationChanged(std::chrono::nanoseconds when) = 0;
 
     /* Notifies the system that an application is not responding.
      * Returns a new timeout to continue waiting, or 0 to abort dispatch. */
-    virtual nsecs_t notifyANR(const sp<InputApplicationHandle>& inputApplicationHandle,
+    virtual std::chrono::nanoseconds notifyANR(const sp<InputApplicationHandle>& inputApplicationHandle,
             const sp<InputWindowHandle>& inputWindowHandle) = 0;
 
     /* Notifies the system that an input channel is unrecoverably broken. */
@@ -246,10 +246,10 @@
      * This method is expected to set the POLICY_FLAG_PASS_TO_USER policy flag if the event
      * should be dispatched to applications.
      */
-    virtual void interceptMotionBeforeQueueing(nsecs_t when, uint32_t& policyFlags) = 0;
+    virtual void interceptMotionBeforeQueueing(std::chrono::nanoseconds when, uint32_t& policyFlags) = 0;
 
     /* Allows the policy a chance to intercept a key before dispatching. */
-    virtual nsecs_t interceptKeyBeforeDispatching(const sp<InputWindowHandle>& inputWindowHandle,
+    virtual std::chrono::nanoseconds interceptKeyBeforeDispatching(const sp<InputWindowHandle>& inputWindowHandle,
             const KeyEvent* keyEvent, uint32_t policyFlags) = 0;
 
     /* Allows the policy a chance to perform default processing for an unhandled key.
@@ -259,11 +259,11 @@
 
     /* Notifies the policy about switch events.
      */
-    virtual void notifySwitch(nsecs_t when,
+    virtual void notifySwitch(std::chrono::nanoseconds when,
             int32_t switchCode, int32_t switchValue, uint32_t policyFlags) = 0;
 
     /* Poke user activity for an event dispatched to a window. */
-    virtual void pokeUserActivity(nsecs_t eventTime, int32_t eventType) = 0;
+    virtual void pokeUserActivity(std::chrono::nanoseconds eventTime, int32_t eventType) = 0;
 
     /* Checks whether a given application pid/uid has permission to inject input events
      * into other applications.
@@ -451,7 +451,7 @@
 
         mutable int32_t refCount;
         int32_t type;
-        nsecs_t eventTime;
+        std::chrono::nanoseconds eventTime;
         uint32_t policyFlags;
         InjectionState* injectionState;
 
@@ -464,13 +464,13 @@
         virtual void appendDescription(String8& msg) const = 0;
 
     protected:
-        EventEntry(int32_t type, nsecs_t eventTime, uint32_t policyFlags);
+        EventEntry(int32_t type, std::chrono::nanoseconds eventTime, uint32_t policyFlags);
         virtual ~EventEntry();
         void releaseInjectionState();
     };
 
     struct ConfigurationChangedEntry : EventEntry {
-        ConfigurationChangedEntry(nsecs_t eventTime);
+        ConfigurationChangedEntry(std::chrono::nanoseconds eventTime);
         virtual void appendDescription(String8& msg) const;
 
     protected:
@@ -480,7 +480,7 @@
     struct DeviceResetEntry : EventEntry {
         int32_t deviceId;
 
-        DeviceResetEntry(nsecs_t eventTime, int32_t deviceId);
+        DeviceResetEntry(std::chrono::nanoseconds eventTime, int32_t deviceId);
         virtual void appendDescription(String8& msg) const;
 
     protected:
@@ -496,7 +496,7 @@
         int32_t scanCode;
         int32_t metaState;
         int32_t repeatCount;
-        nsecs_t downTime;
+        std::chrono::nanoseconds downTime;
 
         bool syntheticRepeat; // set to true for synthetic key repeats
 
@@ -507,12 +507,12 @@
             INTERCEPT_KEY_RESULT_TRY_AGAIN_LATER
         };
         InterceptKeyResult interceptKeyResult; // set based on the interception result
-        nsecs_t interceptKeyWakeupTime; // used with INTERCEPT_KEY_RESULT_TRY_AGAIN_LATER
+        std::chrono::nanoseconds interceptKeyWakeupTime; // used with INTERCEPT_KEY_RESULT_TRY_AGAIN_LATER
 
-        KeyEntry(nsecs_t eventTime,
+        KeyEntry(std::chrono::nanoseconds eventTime,
                 int32_t deviceId, uint32_t source, uint32_t policyFlags, int32_t action,
                 int32_t flags, int32_t keyCode, int32_t scanCode, int32_t metaState,
-                int32_t repeatCount, nsecs_t downTime);
+                int32_t repeatCount, std::chrono::nanoseconds downTime);
         virtual void appendDescription(String8& msg) const;
         void recycle();
 
@@ -521,7 +521,7 @@
     };
 
     struct MotionEntry : EventEntry {
-        nsecs_t eventTime;
+        std::chrono::nanoseconds eventTime;
         int32_t deviceId;
         uint32_t source;
         int32_t action;
@@ -531,16 +531,16 @@
         int32_t edgeFlags;
         float xPrecision;
         float yPrecision;
-        nsecs_t downTime;
+        std::chrono::nanoseconds downTime;
         uint32_t pointerCount;
         PointerProperties pointerProperties[MAX_POINTERS];
         PointerCoords pointerCoords[MAX_POINTERS];
 
-        MotionEntry(nsecs_t eventTime,
+        MotionEntry(std::chrono::nanoseconds eventTime,
                 int32_t deviceId, uint32_t source, uint32_t policyFlags, int32_t action,
                 int32_t flags, int32_t metaState, int32_t buttonState, int32_t edgeFlags,
                 float xPrecision, float yPrecision,
-                nsecs_t downTime, uint32_t pointerCount,
+                std::chrono::nanoseconds downTime, uint32_t pointerCount,
                 const PointerProperties* pointerProperties, const PointerCoords* pointerCoords);
         virtual void appendDescription(String8& msg) const;
 
@@ -557,7 +557,7 @@
         float xOffset;
         float yOffset;
         float scaleFactor;
-        nsecs_t deliveryTime; // time when the event was actually delivered
+        std::chrono::nanoseconds deliveryTime; // time when the event was actually delivered
 
         // Set to the resolved action and flags when the event is enqueued.
         int32_t resolvedAction;
@@ -609,7 +609,7 @@
 
         // parameters for the command (usage varies by command)
         sp<Connection> connection;
-        nsecs_t eventTime;
+        std::chrono::nanoseconds eventTime;
         KeyEntry* keyEntry;
         sp<InputApplicationHandle> inputApplicationHandle;
         sp<InputWindowHandle> inputWindowHandle;
@@ -730,7 +730,7 @@
         bool trackMotion(const MotionEntry* entry, int32_t action, int32_t flags);
 
         // Synthesizes cancelation events for the current state and resets the tracked state.
-        void synthesizeCancelationEvents(nsecs_t currentTime,
+        void synthesizeCancelationEvents(std::chrono::nanoseconds currentTime,
                 Vector<EventEntry*>& outEvents, const CancelationOptions& options);
 
         // Clears the current state.
@@ -762,7 +762,7 @@
             int32_t scanCode;
             int32_t metaState;
             int32_t flags;
-            nsecs_t downTime;
+            std::chrono::nanoseconds downTime;
             uint32_t policyFlags;
         };
 
@@ -772,7 +772,7 @@
             int32_t flags;
             float xPrecision;
             float yPrecision;
-            nsecs_t downTime;
+            std::chrono::nanoseconds downTime;
             uint32_t pointerCount;
             PointerProperties pointerProperties[MAX_POINTERS];
             PointerCoords pointerCoords[MAX_POINTERS];
@@ -864,7 +864,7 @@
     Queue<EventEntry> mInboundQueue;
     Queue<CommandEntry> mCommandQueue;
 
-    void dispatchOnceInnerLocked(nsecs_t* nextWakeupTime);
+    void dispatchOnceInnerLocked(std::chrono::nanoseconds* nextWakeupTime);
 
     // Enqueues an inbound event.  Returns true if mLooper->wake() should be called.
     bool enqueueInboundEventLocked(EventEntry* entry);
@@ -874,7 +874,7 @@
 
     // App switch latency optimization.
     bool mAppSwitchSawKeyDown;
-    nsecs_t mAppSwitchDueTime;
+    std::chrono::nanoseconds mAppSwitchDueTime;
 
     static bool isAppSwitchKeyCode(int32_t keyCode);
     bool isAppSwitchKeyEventLocked(KeyEntry* keyEntry);
@@ -882,7 +882,7 @@
     void resetPendingAppSwitchLocked(bool handled);
 
     // Stale event latency optimization.
-    static bool isStaleEventLocked(nsecs_t currentTime, EventEntry* entry);
+    static bool isStaleEventLocked(std::chrono::nanoseconds currentTime, EventEntry* entry);
 
     // Blocked event latency optimization.  Drops old events when the user intends
     // to transfer focus to a new application.
@@ -910,11 +910,11 @@
     // Key repeat tracking.
     struct KeyRepeatState {
         KeyEntry* lastKeyEntry; // or null if no repeat
-        nsecs_t nextRepeatTime;
+        std::chrono::nanoseconds nextRepeatTime;
     } mKeyRepeatState;
 
     void resetKeyRepeatLocked();
-    KeyEntry* synthesizeKeyRepeatLocked(nsecs_t currentTime);
+    KeyEntry* synthesizeKeyRepeatLocked(std::chrono::nanoseconds currentTime);
 
     // Deferred command processing.
     bool runCommandsLockedInterruptible();
@@ -974,16 +974,16 @@
 
     // Dispatch inbound events.
     bool dispatchConfigurationChangedLocked(
-            nsecs_t currentTime, ConfigurationChangedEntry* entry);
+            std::chrono::nanoseconds currentTime, ConfigurationChangedEntry* entry);
     bool dispatchDeviceResetLocked(
-            nsecs_t currentTime, DeviceResetEntry* entry);
+            std::chrono::nanoseconds currentTime, DeviceResetEntry* entry);
     bool dispatchKeyLocked(
-            nsecs_t currentTime, KeyEntry* entry,
-            DropReason* dropReason, nsecs_t* nextWakeupTime);
+            std::chrono::nanoseconds currentTime, KeyEntry* entry,
+            DropReason* dropReason, std::chrono::nanoseconds* nextWakeupTime);
     bool dispatchMotionLocked(
-            nsecs_t currentTime, MotionEntry* entry,
-            DropReason* dropReason, nsecs_t* nextWakeupTime);
-    void dispatchEventLocked(nsecs_t currentTime, EventEntry* entry,
+            std::chrono::nanoseconds currentTime, MotionEntry* entry,
+            DropReason* dropReason, std::chrono::nanoseconds* nextWakeupTime);
+    void dispatchEventLocked(std::chrono::nanoseconds currentTime, EventEntry* entry,
             const Vector<InputTarget>& inputTargets);
 
     void logOutboundKeyDetailsLocked(const char* prefix, const KeyEntry* entry);
@@ -997,8 +997,8 @@
     };
 
     InputTargetWaitCause mInputTargetWaitCause;
-    nsecs_t mInputTargetWaitStartTime;
-    nsecs_t mInputTargetWaitTimeoutTime;
+    std::chrono::nanoseconds mInputTargetWaitStartTime;
+    std::chrono::nanoseconds mInputTargetWaitTimeoutTime;
     bool mInputTargetWaitTimeoutExpired;
     sp<InputApplicationHandle> mInputTargetWaitApplicationHandle;
 
@@ -1006,19 +1006,19 @@
     sp<InputWindowHandle> mLastHoverWindowHandle;
 
     // Finding targets for input events.
-    int32_t handleTargetsNotReadyLocked(nsecs_t currentTime, const EventEntry* entry,
+    int32_t handleTargetsNotReadyLocked(std::chrono::nanoseconds currentTime, const EventEntry* entry,
             const sp<InputApplicationHandle>& applicationHandle,
             const sp<InputWindowHandle>& windowHandle,
-            nsecs_t* nextWakeupTime, const char* reason);
-    void resumeAfterTargetsNotReadyTimeoutLocked(nsecs_t newTimeout,
+            std::chrono::nanoseconds* nextWakeupTime, const char* reason);
+    void resumeAfterTargetsNotReadyTimeoutLocked(std::chrono::nanoseconds newTimeout,
             const sp<InputChannel>& inputChannel);
-    nsecs_t getTimeSpentWaitingForApplicationLocked(nsecs_t currentTime);
+    std::chrono::nanoseconds getTimeSpentWaitingForApplicationLocked(std::chrono::nanoseconds currentTime);
     void resetANRTimeoutsLocked();
 
-    int32_t findFocusedWindowTargetsLocked(nsecs_t currentTime, const EventEntry* entry,
-            Vector<InputTarget>& inputTargets, nsecs_t* nextWakeupTime);
-    int32_t findTouchedWindowTargetsLocked(nsecs_t currentTime, const MotionEntry* entry,
-            Vector<InputTarget>& inputTargets, nsecs_t* nextWakeupTime,
+    int32_t findFocusedWindowTargetsLocked(std::chrono::nanoseconds currentTime, const EventEntry* entry,
+            Vector<InputTarget>& inputTargets, std::chrono::nanoseconds* nextWakeupTime);
+    int32_t findTouchedWindowTargetsLocked(std::chrono::nanoseconds currentTime, const MotionEntry* entry,
+            Vector<InputTarget>& inputTargets, std::chrono::nanoseconds* nextWakeupTime,
             bool* outConflictingPointerActions);
 
     void addWindowTargetLocked(const sp<InputWindowHandle>& windowHandle,
@@ -1029,7 +1029,7 @@
             const InjectionState* injectionState);
     bool isWindowObscuredAtPointLocked(const sp<InputWindowHandle>& windowHandle,
             int32_t x, int32_t y) const;
-    bool isWindowReadyForMoreInputLocked(nsecs_t currentTime,
+    bool isWindowReadyForMoreInputLocked(std::chrono::nanoseconds currentTime,
             const sp<InputWindowHandle>& windowHandle, const EventEntry* eventEntry);
     String8 getApplicationWindowLabelLocked(const sp<InputApplicationHandle>& applicationHandle,
             const sp<InputWindowHandle>& windowHandle);
@@ -1038,16 +1038,16 @@
     // These methods are deliberately not Interruptible because doing all of the work
     // with the mutex held makes it easier to ensure that connection invariants are maintained.
     // If needed, the methods post commands to run later once the critical bits are done.
-    void prepareDispatchCycleLocked(nsecs_t currentTime, const sp<Connection>& connection,
+    void prepareDispatchCycleLocked(std::chrono::nanoseconds currentTime, const sp<Connection>& connection,
             EventEntry* eventEntry, const InputTarget* inputTarget);
-    void enqueueDispatchEntriesLocked(nsecs_t currentTime, const sp<Connection>& connection,
+    void enqueueDispatchEntriesLocked(std::chrono::nanoseconds currentTime, const sp<Connection>& connection,
             EventEntry* eventEntry, const InputTarget* inputTarget);
     void enqueueDispatchEntryLocked(const sp<Connection>& connection,
             EventEntry* eventEntry, const InputTarget* inputTarget, int32_t dispatchMode);
-    void startDispatchCycleLocked(nsecs_t currentTime, const sp<Connection>& connection);
-    void finishDispatchCycleLocked(nsecs_t currentTime, const sp<Connection>& connection,
+    void startDispatchCycleLocked(std::chrono::nanoseconds currentTime, const sp<Connection>& connection);
+    void finishDispatchCycleLocked(std::chrono::nanoseconds currentTime, const sp<Connection>& connection,
             uint32_t seq, bool handled);
-    void abortBrokenDispatchCycleLocked(nsecs_t currentTime, const sp<Connection>& connection,
+    void abortBrokenDispatchCycleLocked(std::chrono::nanoseconds currentTime, const sp<Connection>& connection,
             bool notify);
     void drainDispatchQueueLocked(Queue<DispatchEntry>* queue);
     void releaseDispatchEntryLocked(DispatchEntry* dispatchEntry);
@@ -1080,13 +1080,13 @@
 
     // Interesting events that we might like to log or tell the framework about.
     void onDispatchCycleFinishedLocked(
-            nsecs_t currentTime, const sp<Connection>& connection, uint32_t seq, bool handled);
+            std::chrono::nanoseconds currentTime, const sp<Connection>& connection, uint32_t seq, bool handled);
     void onDispatchCycleBrokenLocked(
-            nsecs_t currentTime, const sp<Connection>& connection);
+            std::chrono::nanoseconds currentTime, const sp<Connection>& connection);
     void onANRLocked(
-            nsecs_t currentTime, const sp<InputApplicationHandle>& applicationHandle,
+            std::chrono::nanoseconds currentTime, const sp<InputApplicationHandle>& applicationHandle,
             const sp<InputWindowHandle>& windowHandle,
-            nsecs_t eventTime, nsecs_t waitStartTime, const char* reason);
+            std::chrono::nanoseconds eventTime, std::chrono::nanoseconds waitStartTime, const char* reason);
 
     // Outbound policy interactions.
     void doNotifyConfigurationChangedInterruptible(CommandEntry* commandEntry);
@@ -1102,8 +1102,8 @@
     void initializeKeyEvent(KeyEvent* event, const KeyEntry* entry);
 
     // Statistics gathering.
-    void updateDispatchStatisticsLocked(nsecs_t currentTime, const EventEntry* entry,
-            int32_t injectionResult, nsecs_t timeSpentWaitingForApplication);
+    void updateDispatchStatisticsLocked(std::chrono::nanoseconds currentTime, const EventEntry* entry,
+            int32_t injectionResult, std::chrono::nanoseconds timeSpentWaitingForApplication);
 
     void setKeyboardFocusLocked(const sp<InputWindowHandle>& windowHandle);
 };

=== modified file '3rd_party/android-input/android/frameworks/base/services/input/InputListener.cpp'
--- 3rd_party/android-input/android/frameworks/base/services/input/InputListener.cpp	2014-12-08 04:03:47 +0000
+++ 3rd_party/android-input/android/frameworks/base/services/input/InputListener.cpp	2015-02-09 23:59:09 +0000
@@ -26,7 +26,7 @@
 
 // --- NotifyConfigurationChangedArgs ---
 
-NotifyConfigurationChangedArgs::NotifyConfigurationChangedArgs(nsecs_t eventTime) :
+NotifyConfigurationChangedArgs::NotifyConfigurationChangedArgs(std::chrono::nanoseconds eventTime) :
         eventTime(eventTime) {
 }
 
@@ -42,10 +42,10 @@
 
 // --- NotifyKeyArgs ---
 
-NotifyKeyArgs::NotifyKeyArgs(nsecs_t eventTime, int32_t deviceId, uint32_t source,
+NotifyKeyArgs::NotifyKeyArgs(std::chrono::nanoseconds eventTime, int32_t deviceId, uint32_t source,
         uint32_t policyFlags,
         int32_t action, int32_t flags, int32_t keyCode, int32_t scanCode,
-        int32_t metaState, nsecs_t downTime) :
+        int32_t metaState, std::chrono::nanoseconds downTime) :
         eventTime(eventTime), deviceId(deviceId), source(source), policyFlags(policyFlags),
         action(action), flags(flags), keyCode(keyCode), scanCode(scanCode),
         metaState(metaState), downTime(downTime) {
@@ -66,12 +66,12 @@
 
 // --- NotifyMotionArgs ---
 
-NotifyMotionArgs::NotifyMotionArgs(nsecs_t eventTime, int32_t deviceId, uint32_t source,
+NotifyMotionArgs::NotifyMotionArgs(std::chrono::nanoseconds eventTime, int32_t deviceId, uint32_t source,
         uint32_t policyFlags,
         int32_t action, int32_t flags, int32_t metaState, int32_t buttonState,
         int32_t edgeFlags, uint32_t pointerCount,
         const PointerProperties* pointerProperties, const PointerCoords* pointerCoords,
-        float xPrecision, float yPrecision, nsecs_t downTime) :
+        float xPrecision, float yPrecision, std::chrono::nanoseconds downTime) :
         eventTime(eventTime), deviceId(deviceId), source(source), policyFlags(policyFlags),
         action(action), flags(flags), metaState(metaState), buttonState(buttonState),
         edgeFlags(edgeFlags), pointerCount(pointerCount),
@@ -102,7 +102,7 @@
 
 // --- NotifySwitchArgs ---
 
-NotifySwitchArgs::NotifySwitchArgs(nsecs_t eventTime, uint32_t policyFlags,
+NotifySwitchArgs::NotifySwitchArgs(std::chrono::nanoseconds eventTime, uint32_t policyFlags,
         int32_t switchCode, int32_t switchValue) :
         eventTime(eventTime), policyFlags(policyFlags),
         switchCode(switchCode), switchValue(switchValue) {
@@ -120,7 +120,7 @@
 
 // --- NotifyDeviceResetArgs ---
 
-NotifyDeviceResetArgs::NotifyDeviceResetArgs(nsecs_t eventTime, int32_t deviceId) :
+NotifyDeviceResetArgs::NotifyDeviceResetArgs(std::chrono::nanoseconds eventTime, int32_t deviceId) :
         eventTime(eventTime), deviceId(deviceId) {
 }
 

=== modified file '3rd_party/android-input/android/frameworks/base/services/input/InputListener.h'
--- 3rd_party/android-input/android/frameworks/base/services/input/InputListener.h	2014-12-08 04:03:47 +0000
+++ 3rd_party/android-input/android/frameworks/base/services/input/InputListener.h	2015-02-09 23:59:09 +0000
@@ -37,11 +37,11 @@
 
 /* Describes a configuration change event. */
 struct NotifyConfigurationChangedArgs : public NotifyArgs {
-    nsecs_t eventTime;
+    std::chrono::nanoseconds eventTime;
 
     inline NotifyConfigurationChangedArgs() : eventTime{0} { }
 
-    NotifyConfigurationChangedArgs(nsecs_t eventTime);
+    NotifyConfigurationChangedArgs(std::chrono::nanoseconds eventTime);
 
     NotifyConfigurationChangedArgs(const NotifyConfigurationChangedArgs& other);
 
@@ -53,7 +53,7 @@
 
 /* Describes a key event. */
 struct NotifyKeyArgs : public NotifyArgs {
-    nsecs_t eventTime;
+    std::chrono::nanoseconds eventTime;
     int32_t deviceId;
     uint32_t source;
     uint32_t policyFlags;
@@ -62,13 +62,13 @@
     int32_t keyCode;
     int32_t scanCode;
     int32_t metaState;
-    nsecs_t downTime;
+    std::chrono::nanoseconds downTime;
 
     inline NotifyKeyArgs() { }
 
-    NotifyKeyArgs(nsecs_t eventTime, int32_t deviceId, uint32_t source, uint32_t policyFlags,
+    NotifyKeyArgs(std::chrono::nanoseconds eventTime, int32_t deviceId, uint32_t source, uint32_t policyFlags,
             int32_t action, int32_t flags, int32_t keyCode, int32_t scanCode,
-            int32_t metaState, nsecs_t downTime);
+            int32_t metaState, std::chrono::nanoseconds downTime);
 
     NotifyKeyArgs(const NotifyKeyArgs& other);
 
@@ -80,7 +80,7 @@
 
 /* Describes a motion event. */
 struct NotifyMotionArgs : public NotifyArgs {
-    nsecs_t eventTime;
+    std::chrono::nanoseconds eventTime;
     int32_t deviceId;
     uint32_t source;
     uint32_t policyFlags;
@@ -94,15 +94,15 @@
     PointerCoords pointerCoords[MAX_POINTERS];
     float xPrecision;
     float yPrecision;
-    nsecs_t downTime;
+    std::chrono::nanoseconds downTime;
 
     inline NotifyMotionArgs() { }
 
-    NotifyMotionArgs(nsecs_t eventTime, int32_t deviceId, uint32_t source, uint32_t policyFlags,
+    NotifyMotionArgs(std::chrono::nanoseconds eventTime, int32_t deviceId, uint32_t source, uint32_t policyFlags,
             int32_t action, int32_t flags, int32_t metaState, int32_t buttonState,
             int32_t edgeFlags, uint32_t pointerCount,
             const PointerProperties* pointerProperties, const PointerCoords* pointerCoords,
-            float xPrecision, float yPrecision, nsecs_t downTime);
+            float xPrecision, float yPrecision, std::chrono::nanoseconds downTime);
 
     NotifyMotionArgs(const NotifyMotionArgs& other);
 
@@ -114,14 +114,14 @@
 
 /* Describes a switch event. */
 struct NotifySwitchArgs : public NotifyArgs {
-    nsecs_t eventTime;
+    std::chrono::nanoseconds eventTime;
     uint32_t policyFlags;
     int32_t switchCode;
     int32_t switchValue;
 
     inline NotifySwitchArgs() { }
 
-    NotifySwitchArgs(nsecs_t eventTime, uint32_t policyFlags,
+    NotifySwitchArgs(std::chrono::nanoseconds eventTime, uint32_t policyFlags,
             int32_t switchCode, int32_t switchValue);
 
     NotifySwitchArgs(const NotifySwitchArgs& other);
@@ -135,12 +135,12 @@
 /* Describes a device reset event, such as when a device is added,
  * reconfigured, or removed. */
 struct NotifyDeviceResetArgs : public NotifyArgs {
-    nsecs_t eventTime;
+    std::chrono::nanoseconds eventTime;
     int32_t deviceId;
 
     inline NotifyDeviceResetArgs() { }
 
-    NotifyDeviceResetArgs(nsecs_t eventTime, int32_t deviceId);
+    NotifyDeviceResetArgs(std::chrono::nanoseconds eventTime, int32_t deviceId);
 
     NotifyDeviceResetArgs(const NotifyDeviceResetArgs& other);
 

=== modified file '3rd_party/android-input/android/frameworks/base/services/input/InputReader.cpp'
--- 3rd_party/android-input/android/frameworks/base/services/input/InputReader.cpp	2014-12-08 04:03:47 +0000
+++ 3rd_party/android-input/android/frameworks/base/services/input/InputReader.cpp	2015-02-09 23:59:09 +0000
@@ -181,7 +181,7 @@
 }
 
 static void synthesizeButtonKey(InputReaderContext* context, int32_t action,
-        nsecs_t when, int32_t deviceId, uint32_t source,
+        std::chrono::nanoseconds when, int32_t deviceId, uint32_t source,
         uint32_t policyFlags, int32_t lastButtonState, int32_t currentButtonState,
         int32_t buttonState, int32_t keyCode) {
     if (
@@ -198,7 +198,7 @@
 }
 
 static void synthesizeButtonKeys(InputReaderContext* context, int32_t action,
-        nsecs_t when, int32_t deviceId, uint32_t source,
+        std::chrono::nanoseconds when, int32_t deviceId, uint32_t source,
         uint32_t policyFlags, int32_t lastButtonState, int32_t currentButtonState) {
     synthesizeButtonKey(context, action, when, deviceId, source, policyFlags,
             lastButtonState, currentButtonState,
@@ -283,8 +283,8 @@
             mConfigurationChangesToRefresh = 0;
             timeoutMillis = 0;
             refreshConfigurationLocked(changes);
-        } else if (mNextTimeout != LLONG_MAX) {
-            nsecs_t now = systemTime(SYSTEM_TIME_MONOTONIC);
+        } else if (mNextTimeout != std::chrono::nanoseconds(LLONG_MAX)) {
+            std::chrono::nanoseconds now = systemTime(SYSTEM_TIME_MONOTONIC);
             timeoutMillis = toMillisecondTimeoutDelay(now, mNextTimeout);
         }
     } // release lock
@@ -299,13 +299,13 @@
             processEventsLocked(mEventBuffer, count);
         }
 
-        if (mNextTimeout != LLONG_MAX) {
-            nsecs_t now = systemTime(SYSTEM_TIME_MONOTONIC);
+        if (mNextTimeout != std::chrono::nanoseconds(LLONG_MAX)) {
+            std::chrono::nanoseconds now = systemTime(SYSTEM_TIME_MONOTONIC);
             if (now >= mNextTimeout) {
 #if DEBUG_RAW_EVENTS
                 ALOGD("Timeout expired, latency=%0.3fms", (now - mNextTimeout) * 0.000001f);
 #endif
-                mNextTimeout = LLONG_MAX;
+                mNextTimeout = std::chrono::nanoseconds(LLONG_MAX);
                 timeoutExpiredLocked(now);
             }
         }
@@ -369,7 +369,7 @@
     }
 }
 
-void InputReader::addDeviceLocked(nsecs_t when, int32_t deviceId) {
+void InputReader::addDeviceLocked(std::chrono::nanoseconds when, int32_t deviceId) {
     ssize_t deviceIndex = mDevices.indexOfKey(deviceId);
     if (deviceIndex >= 0) {
         ALOGW("Ignoring spurious device added event for deviceId %d.", deviceId);
@@ -395,7 +395,7 @@
     bumpGenerationLocked();
 }
 
-void InputReader::removeDeviceLocked(nsecs_t when, int32_t deviceId) {
+void InputReader::removeDeviceLocked(std::chrono::nanoseconds when, int32_t deviceId) {
     InputDevice* device = NULL;
     ssize_t deviceIndex = mDevices.indexOfKey(deviceId);
     if (deviceIndex < 0) {
@@ -496,7 +496,7 @@
     device->process(rawEvents, count);
 }
 
-void InputReader::timeoutExpiredLocked(nsecs_t when) {
+void InputReader::timeoutExpiredLocked(std::chrono::nanoseconds when) {
     for (size_t i = 0; i < mDevices.size(); i++) {
         InputDevice* device = mDevices.valueAt(i);
         if (!device->isIgnored()) {
@@ -505,7 +505,7 @@
     }
 }
 
-void InputReader::handleConfigurationChangedLocked(nsecs_t when) {
+void InputReader::handleConfigurationChangedLocked(std::chrono::nanoseconds when) {
     // Reset global meta state because it depends on the list of all configured devices.
     updateGlobalMetaStateLocked();
 
@@ -520,7 +520,7 @@
 
     if (changes) {
         ALOGI("Reconfiguring input devices.  changes=0x%08x", changes);
-        nsecs_t now = systemTime(SYSTEM_TIME_MONOTONIC);
+        std::chrono::nanoseconds now = systemTime(SYSTEM_TIME_MONOTONIC);
 
         if (changes & InputReaderConfiguration::CHANGE_MUST_REOPEN) {
             mEventHub->requestReopenDevices();
@@ -546,11 +546,11 @@
     return mGlobalMetaState;
 }
 
-void InputReader::disableVirtualKeysUntilLocked(nsecs_t time) {
+void InputReader::disableVirtualKeysUntilLocked(std::chrono::nanoseconds time) {
     mDisableVirtualKeysTimeout = time;
 }
 
-bool InputReader::shouldDropVirtualKeyLocked(nsecs_t now,
+bool InputReader::shouldDropVirtualKeyLocked(std::chrono::nanoseconds now,
         InputDevice* device, int32_t keyCode, int32_t scanCode) {
     if (now < mDisableVirtualKeysTimeout) {
         ALOGI("Dropping virtual key from device %s because virtual keys are "
@@ -571,7 +571,7 @@
     }
 }
 
-void InputReader::requestTimeoutAtTimeLocked(nsecs_t when) {
+void InputReader::requestTimeoutAtTimeLocked(std::chrono::nanoseconds when) {
     if (when < mNextTimeout) {
         mNextTimeout = when;
         mEventHub->wake();
@@ -696,7 +696,7 @@
     }
 }
 
-void InputReader::vibrate(int32_t deviceId, const nsecs_t* pattern, size_t patternSize,
+void InputReader::vibrate(int32_t deviceId, const std::chrono::nanoseconds* pattern, size_t patternSize,
         ssize_t repeat, int32_t token) {
     AutoMutex _l(mLock);
 
@@ -810,12 +810,12 @@
     return mReader->getGlobalMetaStateLocked();
 }
 
-void InputReader::ContextImpl::disableVirtualKeysUntil(nsecs_t time) {
+void InputReader::ContextImpl::disableVirtualKeysUntil(std::chrono::nanoseconds time) {
     // lock is already held by the input loop
     mReader->disableVirtualKeysUntilLocked(time);
 }
 
-bool InputReader::ContextImpl::shouldDropVirtualKey(nsecs_t now,
+bool InputReader::ContextImpl::shouldDropVirtualKey(std::chrono::nanoseconds now,
         InputDevice* device, int32_t keyCode, int32_t scanCode) {
     // lock is already held by the input loop
     return mReader->shouldDropVirtualKeyLocked(now, device, keyCode, scanCode);
@@ -826,7 +826,7 @@
     mReader->fadePointerLocked();
 }
 
-void InputReader::ContextImpl::requestTimeoutAtTime(nsecs_t when) {
+void InputReader::ContextImpl::requestTimeoutAtTime(std::chrono::nanoseconds when) {
     // lock is already held by the input loop
     mReader->requestTimeoutAtTimeLocked(when);
 }
@@ -922,7 +922,7 @@
     mMappers.add(mapper);
 }
 
-void InputDevice::configure(nsecs_t when, InputReaderConfiguration const* config, uint32_t changes) {
+void InputDevice::configure(std::chrono::nanoseconds when, InputReaderConfiguration const* config, uint32_t changes) {
     mSources = 0;
 
     if (!isIgnored()) {
@@ -959,7 +959,7 @@
     }
 }
 
-void InputDevice::reset(nsecs_t when) {
+void InputDevice::reset(std::chrono::nanoseconds when) {
     size_t numMappers = mMappers.size();
     for (size_t i = 0; i < numMappers; i++) {
         InputMapper* mapper = mMappers[i];
@@ -1009,7 +1009,7 @@
     }
 }
 
-void InputDevice::timeoutExpired(nsecs_t when) {
+void InputDevice::timeoutExpired(std::chrono::nanoseconds when) {
     size_t numMappers = mMappers.size();
     for (size_t i = 0; i < numMappers; i++) {
         InputMapper* mapper = mMappers[i];
@@ -1071,7 +1071,7 @@
     return result;
 }
 
-void InputDevice::vibrate(const nsecs_t* pattern, size_t patternSize, ssize_t repeat,
+void InputDevice::vibrate(const std::chrono::nanoseconds* pattern, size_t patternSize, ssize_t repeat,
         int32_t token) {
     size_t numMappers = mMappers.size();
     for (size_t i = 0; i < numMappers; i++) {
@@ -1110,7 +1110,7 @@
     mGeneration = mContext->bumpGeneration();
 }
 
-void InputDevice::notifyReset(nsecs_t when) {
+void InputDevice::notifyReset(std::chrono::nanoseconds when) {
     NotifyDeviceResetArgs args(when, mId);
     mContext->getListener()->notifyDeviceReset(&args);
 }
@@ -1760,14 +1760,14 @@
 void InputMapper::dump(String8& dump) {
 }
 
-void InputMapper::configure(nsecs_t when, 
+void InputMapper::configure(std::chrono::nanoseconds when, 
         const InputReaderConfiguration* config, uint32_t changes) {
 }
 
-void InputMapper::reset(nsecs_t when) {
+void InputMapper::reset(std::chrono::nanoseconds when) {
 }
 
-void InputMapper::timeoutExpired(nsecs_t when) {
+void InputMapper::timeoutExpired(std::chrono::nanoseconds when) {
 }
 
 int32_t InputMapper::getKeyCodeState(uint32_t sourceMask, int32_t keyCode) {
@@ -1787,7 +1787,7 @@
     return false;
 }
 
-void InputMapper::vibrate(const nsecs_t* pattern, size_t patternSize, ssize_t repeat,
+void InputMapper::vibrate(const std::chrono::nanoseconds* pattern, size_t patternSize, ssize_t repeat,
         int32_t token) {
 }
 
@@ -1841,7 +1841,7 @@
     }
 }
 
-void SwitchInputMapper::processSwitch(nsecs_t when, int32_t switchCode, int32_t switchValue) {
+void SwitchInputMapper::processSwitch(std::chrono::nanoseconds when, int32_t switchCode, int32_t switchValue) {
     NotifySwitchArgs args(when, 0, switchCode, switchValue);
     getListener()->notifySwitch(&args);
 }
@@ -1874,7 +1874,7 @@
     // TODO: Handle FF_STATUS, although it does not seem to be widely supported.
 }
 
-void VibratorInputMapper::vibrate(const nsecs_t* pattern, size_t patternSize, ssize_t repeat,
+void VibratorInputMapper::vibrate(const std::chrono::nanoseconds* pattern, size_t patternSize, ssize_t repeat,
         int32_t token) {
 #if DEBUG_VIBRATOR
     String8 patternStr;
@@ -1889,7 +1889,7 @@
 #endif
 
     mVibrating = true;
-    memcpy(mPattern, pattern, patternSize * sizeof(nsecs_t));
+    memcpy(mPattern, pattern, patternSize * sizeof(std::chrono::nanoseconds));
     mPatternSize = patternSize;
     mRepeat = repeat;
     mToken = token;
@@ -1908,7 +1908,7 @@
     }
 }
 
-void VibratorInputMapper::timeoutExpired(nsecs_t when) {
+void VibratorInputMapper::timeoutExpired(std::chrono::nanoseconds when) {
     if (mVibrating) {
         if (when >= mNextStepTime) {
             nextStep();
@@ -1930,7 +1930,7 @@
     }
 
     bool vibratorOn = mIndex & 1;
-    nsecs_t duration = mPattern[mIndex];
+    std::chrono::nanoseconds duration = mPattern[mIndex];
     if (vibratorOn) {
 #if DEBUG_VIBRATOR
         ALOGD("nextStep: sending vibrate deviceId=%d, duration=%lld",
@@ -1943,7 +1943,7 @@
 #endif
         getEventHub()->cancelVibrate(getDeviceId());
     }
-    nsecs_t now = systemTime(SYSTEM_TIME_MONOTONIC);
+    std::chrono::nanoseconds now = systemTime(SYSTEM_TIME_MONOTONIC);
     mNextStepTime = now + duration;
     getContext()->requestTimeoutAtTime(mNextStepTime);
 #if DEBUG_VIBRATOR
@@ -1998,7 +1998,7 @@
 }
 
 
-void KeyboardInputMapper::configure(nsecs_t when, InputReaderConfiguration const* config, uint32_t changes) {
+void KeyboardInputMapper::configure(std::chrono::nanoseconds when, InputReaderConfiguration const* config, uint32_t changes) {
     InputMapper::configure(when, config, changes);
 
     if (!changes) { // first time only
@@ -2037,9 +2037,9 @@
             toString(mParameters.orientationAware));
 }
 
-void KeyboardInputMapper::reset(nsecs_t when) {
+void KeyboardInputMapper::reset(std::chrono::nanoseconds when) {
     mMetaState = AMETA_NONE;
-    mDownTime = 0;
+    mDownTime = std::chrono::nanoseconds(0);
     mKeyDowns.clear();
     mCurrentHidUsage = 0;
 
@@ -2087,7 +2087,7 @@
         || (scanCode >= BTN_JOYSTICK && scanCode < BTN_DIGI);
 }
 
-void KeyboardInputMapper::processKey(nsecs_t when, bool down, int32_t keyCode,
+void KeyboardInputMapper::processKey(std::chrono::nanoseconds when, bool down, int32_t keyCode,
         int32_t scanCode, uint32_t policyFlags) {
 
     if (down) {
@@ -2141,7 +2141,7 @@
         updateLedState(false);
     }
 
-    nsecs_t downTime = mDownTime;
+    std::chrono::nanoseconds downTime = mDownTime;
 
     // Key down on external an keyboard should wake the device.
     // We don't do this for internal keyboards to prevent them from waking up in your pocket.
@@ -2283,7 +2283,7 @@
     appendFormat(dump, INDENT3 "DownTime: %lld\n", mDownTime);
 }
 
-void CursorInputMapper::configure(nsecs_t when, InputReaderConfiguration const* config, uint32_t changes) {
+void CursorInputMapper::configure(std::chrono::nanoseconds when, InputReaderConfiguration const* config, uint32_t changes) {
     InputMapper::configure(when, config, changes);
 
     if (!changes) { // first time only
@@ -2375,9 +2375,9 @@
             toString(mParameters.orientationAware));
 }
 
-void CursorInputMapper::reset(nsecs_t when) {
+void CursorInputMapper::reset(std::chrono::nanoseconds when) {
     mButtonState = 0;
-    mDownTime = 0;
+    mDownTime = std::chrono::nanoseconds(0);
 
     mPointerVelocityControl.reset();
     mWheelXVelocityControl.reset();
@@ -2400,7 +2400,7 @@
     }
 }
 
-void CursorInputMapper::sync(nsecs_t when) {
+void CursorInputMapper::sync(std::chrono::nanoseconds when) {
     int32_t lastButtonState = mButtonState;
     int32_t currentButtonState = mCursorButtonAccumulator.getButtonState();
     mButtonState = currentButtonState;
@@ -2416,7 +2416,7 @@
     } else {
         downChanged = false;
     }
-    nsecs_t downTime = mDownTime;
+    std::chrono::nanoseconds downTime = mDownTime;
     bool buttonsChanged = currentButtonState != lastButtonState;
     bool buttonsPressed = currentButtonState & ~lastButtonState;
 
@@ -2692,7 +2692,7 @@
     }
 }
 
-void TouchInputMapper::configure(nsecs_t when, const InputReaderConfiguration* config,
+void TouchInputMapper::configure(std::chrono::nanoseconds when, const InputReaderConfiguration* config,
     uint32_t changes) {
     InputMapper::configure(when, config, changes);
 
@@ -2850,7 +2850,7 @@
     dumpRawAbsoluteAxisInfo(dump, mRawPointerAxes.slot, "Slot");
 }
 
-void TouchInputMapper::configureSurface(nsecs_t when, bool* outResetNeeded) {
+void TouchInputMapper::configureSurface(std::chrono::nanoseconds when, bool* outResetNeeded) {
     int32_t oldDeviceMode = mDeviceMode;
 
     // Determine device mode.
@@ -3479,7 +3479,7 @@
     }
 }
 
-void TouchInputMapper::reset(nsecs_t when) {
+void TouchInputMapper::reset(std::chrono::nanoseconds when) {
     mCursorButtonAccumulator.reset(getDevice());
     mCursorScrollAccumulator.reset(getDevice());
     mTouchButtonAccumulator.reset(getDevice());
@@ -3504,7 +3504,7 @@
     mLastMouseIds.clear();
     mPointerUsage = POINTER_USAGE_NONE;
     mSentHoverEnter = false;
-    mDownTime = 0;
+    mDownTime = std::chrono::nanoseconds(0);
 
     mCurrentVirtualKey.down = false;
 
@@ -3529,7 +3529,7 @@
     }
 }
 
-void TouchInputMapper::sync(nsecs_t when) {
+void TouchInputMapper::sync(std::chrono::nanoseconds when) {
     // Sync button state.
     mCurrentButtonState = mTouchButtonAccumulator.getButtonState()
             | mCursorButtonAccumulator.getButtonState();
@@ -3686,7 +3686,7 @@
     mCurrentRawHScroll = 0;
 }
 
-void TouchInputMapper::timeoutExpired(nsecs_t when) {
+void TouchInputMapper::timeoutExpired(std::chrono::nanoseconds when) {
     if (mDeviceMode == DEVICE_MODE_POINTER) {
         if (mPointerUsage == POINTER_USAGE_GESTURES) {
             dispatchPointerGestures(when, 0 /*policyFlags*/, true /*isTimeout*/);
@@ -3694,7 +3694,7 @@
     }
 }
 
-bool TouchInputMapper::consumeRawTouches(nsecs_t when, uint32_t policyFlags) {
+bool TouchInputMapper::consumeRawTouches(std::chrono::nanoseconds when, uint32_t policyFlags) {
     // Check for release of a virtual key.
     if (mCurrentVirtualKey.down) {
         if (mCurrentRawPointerData.touchingIds.isEmpty()) {
@@ -3787,17 +3787,17 @@
     //    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.touchingIds.isEmpty()) {
+    if (mConfig.virtualKeyQuietTime > std::chrono::nanoseconds(0) && !mCurrentRawPointerData.touchingIds.isEmpty()) {
         mContext->disableVirtualKeysUntil(when + mConfig.virtualKeyQuietTime);
     }
     return false;
 }
 
-void TouchInputMapper::dispatchVirtualKey(nsecs_t when, uint32_t policyFlags,
+void TouchInputMapper::dispatchVirtualKey(std::chrono::nanoseconds when, uint32_t policyFlags,
         int32_t keyEventAction, int32_t keyEventFlags) {
     int32_t keyCode = mCurrentVirtualKey.keyCode;
     int32_t scanCode = mCurrentVirtualKey.scanCode;
-    nsecs_t downTime = mCurrentVirtualKey.downTime;
+    std::chrono::nanoseconds downTime = mCurrentVirtualKey.downTime;
     int32_t metaState = mContext->getGlobalMetaState();
     policyFlags |= POLICY_FLAG_VIRTUAL;
 
@@ -3806,7 +3806,7 @@
     getListener()->notifyKey(&args);
 }
 
-void TouchInputMapper::dispatchTouches(nsecs_t when, uint32_t policyFlags) {
+void TouchInputMapper::dispatchTouches(std::chrono::nanoseconds when, uint32_t policyFlags) {
     IntSet &currentIds = mCurrentCookedPointerData.touchingIds;
     IntSet &lastIds = mLastCookedPointerData.touchingIds;
     int32_t metaState = getContext()->getGlobalMetaState();
@@ -3893,7 +3893,7 @@
     }
 }
 
-void TouchInputMapper::dispatchHoverExit(nsecs_t when, uint32_t policyFlags) {
+void TouchInputMapper::dispatchHoverExit(std::chrono::nanoseconds when, uint32_t policyFlags) {
     if (mSentHoverEnter &&
             (mCurrentCookedPointerData.hoveringIds.isEmpty()
                     || !mCurrentCookedPointerData.touchingIds.isEmpty())) {
@@ -3909,7 +3909,7 @@
     }
 }
 
-void TouchInputMapper::dispatchHoverEnterAndMove(nsecs_t when, uint32_t policyFlags) {
+void TouchInputMapper::dispatchHoverEnterAndMove(std::chrono::nanoseconds when, uint32_t policyFlags) {
     if (mCurrentCookedPointerData.touchingIds.isEmpty()
             && !mCurrentCookedPointerData.hoveringIds.isEmpty()) {
         int32_t metaState = getContext()->getGlobalMetaState();
@@ -4135,7 +4135,7 @@
     }
 }
 
-void TouchInputMapper::dispatchPointerUsage(nsecs_t when, uint32_t policyFlags,
+void TouchInputMapper::dispatchPointerUsage(std::chrono::nanoseconds when, uint32_t policyFlags,
         PointerUsage pointerUsage) {
     if (pointerUsage != mPointerUsage) {
         abortPointerUsage(when, policyFlags);
@@ -4157,7 +4157,7 @@
     }
 }
 
-void TouchInputMapper::abortPointerUsage(nsecs_t when, uint32_t policyFlags) {
+void TouchInputMapper::abortPointerUsage(std::chrono::nanoseconds when, uint32_t policyFlags) {
     switch (mPointerUsage) {
     case POINTER_USAGE_GESTURES:
         abortPointerGestures(when, policyFlags);
@@ -4175,7 +4175,7 @@
     mPointerUsage = POINTER_USAGE_NONE;
 }
 
-void TouchInputMapper::dispatchPointerGestures(nsecs_t when, uint32_t policyFlags,
+void TouchInputMapper::dispatchPointerGestures(std::chrono::nanoseconds when, uint32_t policyFlags,
         bool isTimeout) {
     // Update current gesture coordinates.
     bool cancelPreviousGesture, finishPreviousGesture;
@@ -4376,7 +4376,7 @@
     }
 }
 
-void TouchInputMapper::abortPointerGestures(nsecs_t when, uint32_t policyFlags) {
+void TouchInputMapper::abortPointerGestures(std::chrono::nanoseconds when, uint32_t policyFlags) {
     // Cancel previously dispatches pointers.
     if (!mPointerGesture.lastGestureIds.isEmpty()) {
         int32_t metaState = getContext()->getGlobalMetaState();
@@ -4400,7 +4400,7 @@
     }
 }
 
-bool TouchInputMapper::preparePointerGestures(nsecs_t when,
+bool TouchInputMapper::preparePointerGestures(std::chrono::nanoseconds when,
         bool* outCancelPreviousGesture, bool* outFinishPreviousGesture, bool isTimeout) {
     *outCancelPreviousGesture = false;
     *outFinishPreviousGesture = false;
@@ -5148,7 +5148,7 @@
     return true;
 }
 
-void TouchInputMapper::dispatchPointerStylus(nsecs_t when, uint32_t policyFlags) {
+void TouchInputMapper::dispatchPointerStylus(std::chrono::nanoseconds when, uint32_t policyFlags) {
     mPointerSimple.currentCoords.clear();
     mPointerSimple.currentProperties.clear();
 
@@ -5178,11 +5178,11 @@
     dispatchPointerSimple(when, policyFlags, down, hovering);
 }
 
-void TouchInputMapper::abortPointerStylus(nsecs_t when, uint32_t policyFlags) {
+void TouchInputMapper::abortPointerStylus(std::chrono::nanoseconds when, uint32_t policyFlags) {
     abortPointerSimple(when, policyFlags);
 }
 
-void TouchInputMapper::dispatchPointerMouse(nsecs_t when, uint32_t policyFlags) {
+void TouchInputMapper::dispatchPointerMouse(std::chrono::nanoseconds when, uint32_t policyFlags) {
     mPointerSimple.currentCoords.clear();
     mPointerSimple.currentProperties.clear();
 
@@ -5231,13 +5231,13 @@
     dispatchPointerSimple(when, policyFlags, down, hovering);
 }
 
-void TouchInputMapper::abortPointerMouse(nsecs_t when, uint32_t policyFlags) {
+void TouchInputMapper::abortPointerMouse(std::chrono::nanoseconds when, uint32_t policyFlags) {
     abortPointerSimple(when, policyFlags);
 
     mPointerVelocityControl.reset();
 }
 
-void TouchInputMapper::dispatchPointerSimple(nsecs_t when, uint32_t policyFlags,
+void TouchInputMapper::dispatchPointerSimple(std::chrono::nanoseconds when, uint32_t policyFlags,
         bool down, bool hovering) {
     int32_t metaState = getContext()->getGlobalMetaState();
 
@@ -5350,17 +5350,17 @@
     }
 }
 
-void TouchInputMapper::abortPointerSimple(nsecs_t when, uint32_t policyFlags) {
+void TouchInputMapper::abortPointerSimple(std::chrono::nanoseconds when, uint32_t policyFlags) {
     mPointerSimple.currentCoords.clear();
     mPointerSimple.currentProperties.clear();
 
     dispatchPointerSimple(when, policyFlags, false, false);
 }
 
-void TouchInputMapper::dispatchMotion(nsecs_t when, uint32_t policyFlags, uint32_t source,
+void TouchInputMapper::dispatchMotion(std::chrono::nanoseconds 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,
-        int32_t changedId, float xPrecision, float yPrecision, nsecs_t downTime) {
+        int32_t changedId, float xPrecision, float yPrecision, std::chrono::nanoseconds downTime) {
     PointerCoords pointerCoords[MAX_POINTERS];
     PointerProperties pointerProperties[MAX_POINTERS];
     uint32_t pointerCount = 0;
@@ -5398,11 +5398,11 @@
     getListener()->notifyMotion(&args);
 }
 
-void TouchInputMapper::dispatchMotion(nsecs_t when, uint32_t policyFlags, uint32_t source,
+void TouchInputMapper::dispatchMotion(std::chrono::nanoseconds 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) {
+        int32_t changedId, float xPrecision, float yPrecision, std::chrono::nanoseconds downTime) {
     PointerCoords pointerCoords[MAX_POINTERS];
     PointerProperties pointerProperties[MAX_POINTERS];
     uint32_t pointerCount = 0;
@@ -5768,7 +5768,7 @@
 SingleTouchInputMapper::~SingleTouchInputMapper() {
 }
 
-void SingleTouchInputMapper::reset(nsecs_t when) {
+void SingleTouchInputMapper::reset(std::chrono::nanoseconds when) {
     mSingleTouchMotionAccumulator.reset(getDevice());
 
     TouchInputMapper::reset(when);
@@ -5780,7 +5780,7 @@
     mSingleTouchMotionAccumulator.process(rawEvent);
 }
 
-void SingleTouchInputMapper::syncTouch(nsecs_t when, bool* outHavePointerIds) {
+void SingleTouchInputMapper::syncTouch(std::chrono::nanoseconds when, bool* outHavePointerIds) {
     if (mTouchButtonAccumulator.isToolActive()) {
         mCurrentRawPointerData.pointerCount = 1;
 
@@ -5844,7 +5844,7 @@
 MultiTouchInputMapper::~MultiTouchInputMapper() {
 }
 
-void MultiTouchInputMapper::reset(nsecs_t when) {
+void MultiTouchInputMapper::reset(std::chrono::nanoseconds when) {
     mMultiTouchMotionAccumulator.reset(getDevice());
 
     mPointerIds.clear();
@@ -5858,7 +5858,7 @@
     mMultiTouchMotionAccumulator.process(rawEvent);
 }
 
-void MultiTouchInputMapper::syncTouch(nsecs_t when, bool* outHavePointerIds) {
+void MultiTouchInputMapper::syncTouch(std::chrono::nanoseconds when, bool* outHavePointerIds) {
     size_t inCount = mMultiTouchMotionAccumulator.getSlotCount();
     size_t outCount = 0;
     IntSet newPointerIds;
@@ -6046,7 +6046,7 @@
     }
 }
 
-void JoystickInputMapper::configure(nsecs_t when, const InputReaderConfiguration* config, uint32_t changes) {
+void JoystickInputMapper::configure(std::chrono::nanoseconds when, const InputReaderConfiguration* config, uint32_t changes) {
     InputMapper::configure(when, config, changes);
 
     if (!changes) { // first time only
@@ -6181,7 +6181,7 @@
     }
 }
 
-void JoystickInputMapper::reset(nsecs_t when) {
+void JoystickInputMapper::reset(std::chrono::nanoseconds when) {
     // Recenter all axes.
     size_t numAxes = mAxes.size();
     for (size_t i = 0; i < numAxes; i++) {
@@ -6240,7 +6240,7 @@
     }
 }
 
-void JoystickInputMapper::sync(nsecs_t when, bool force) {
+void JoystickInputMapper::sync(std::chrono::nanoseconds when, bool force) {
     if (!filterAxes(force)) {
         return;
     }
@@ -6273,7 +6273,7 @@
 
     NotifyMotionArgs args(when, getDeviceId(), AINPUT_SOURCE_JOYSTICK, policyFlags,
             AMOTION_EVENT_ACTION_MOVE, 0, metaState, buttonState, AMOTION_EVENT_EDGE_FLAG_NONE,
-            1, &pointerProperties, &pointerCoords, 0, 0, 0);
+                          1, &pointerProperties, &pointerCoords, 0, 0, std::chrono::nanoseconds(0));
     getListener()->notifyMotion(&args);
 }
 

=== modified file '3rd_party/android-input/android/frameworks/base/services/input/InputReader.h'
--- 3rd_party/android-input/android/frameworks/base/services/input/InputReader.h	2014-12-08 04:03:47 +0000
+++ 3rd_party/android-input/android/frameworks/base/services/input/InputReader.h	2015-02-09 23:59:09 +0000
@@ -86,7 +86,7 @@
     // Gets the amount of time to disable virtual keys after the screen is touched
     // in order to filter out accidental virtual key presses due to swiping gestures
     // or taps near the edge of the display.  May be 0 to disable the feature.
-    nsecs_t virtualKeyQuietTime;
+    std::chrono::nanoseconds virtualKeyQuietTime;
 
     // The excluded device names for the platform.
     // Devices with these names will be ignored.
@@ -104,7 +104,7 @@
     // Quiet time between certain pointer gesture transitions.
     // Time to allow for all fingers or buttons to settle into a stable state before
     // starting a new gesture.
-    nsecs_t pointerGestureQuietInterval;
+    std::chrono::nanoseconds pointerGestureQuietInterval;
 
     // The minimum speed that a pointer must travel for us to consider switching the active
     // touch pointer to it during a drag.  This threshold is set to avoid switching due
@@ -113,7 +113,7 @@
 
     // Tap gesture delay time.
     // The time between down and up must be less than this to be considered a tap.
-    nsecs_t pointerGestureTapInterval;
+    std::chrono::nanoseconds pointerGestureTapInterval;
 
     // Tap drag gesture delay time.
     // The time between the previous tap's up and the next down must be less than
@@ -122,7 +122,7 @@
     //
     // Note that the previous tap will be held down for this entire duration so this
     // interval must be shorter than the long press timeout.
-    nsecs_t pointerGestureTapDragInterval;
+    std::chrono::nanoseconds pointerGestureTapDragInterval;
 
     // The distance in pixels that the pointer is allowed to move from initial down
     // to up and still be called a tap.
@@ -131,7 +131,7 @@
     // Time after the first touch points go down to settle on an initial centroid.
     // This is intended to be enough time to handle cases where the user puts down two
     // fingers at almost but not quite exactly the same time.
-    nsecs_t pointerGestureMultitouchSettleInterval;
+    std::chrono::nanoseconds pointerGestureMultitouchSettleInterval;
 
     // The transition from PRESS to SWIPE or FREEFORM gesture mode is made when
     // at least two pointers have moved at least this far from their starting place.
@@ -293,7 +293,7 @@
     virtual void requestRefreshConfiguration(uint32_t changes) = 0;
 
     /* Controls the vibrator of a particular input device. */
-    virtual void vibrate(int32_t deviceId, const nsecs_t* pattern, size_t patternSize,
+    virtual void vibrate(int32_t deviceId, const std::chrono::nanoseconds* pattern, size_t patternSize,
             ssize_t repeat, int32_t token) = 0;
     virtual void cancelVibrate(int32_t deviceId, int32_t token) = 0;
 };
@@ -310,13 +310,13 @@
     virtual void updateGlobalMetaState() = 0;
     virtual int32_t getGlobalMetaState() = 0;
 
-    virtual void disableVirtualKeysUntil(nsecs_t time) = 0;
-    virtual bool shouldDropVirtualKey(nsecs_t now,
+    virtual void disableVirtualKeysUntil(std::chrono::nanoseconds time) = 0;
+    virtual bool shouldDropVirtualKey(std::chrono::nanoseconds now,
             InputDevice* device, int32_t keyCode, int32_t scanCode) = 0;
 
     virtual void fadePointer() = 0;
 
-    virtual void requestTimeoutAtTime(nsecs_t when) = 0;
+    virtual void requestTimeoutAtTime(std::chrono::nanoseconds when) = 0;
     virtual int32_t bumpGeneration() = 0;
 
     virtual InputReaderPolicyInterface* getPolicy() = 0;
@@ -362,7 +362,7 @@
 
     virtual void requestRefreshConfiguration(uint32_t changes);
 
-    virtual void vibrate(int32_t deviceId, const nsecs_t* pattern, size_t patternSize,
+    virtual void vibrate(int32_t deviceId, const std::chrono::nanoseconds* pattern, size_t patternSize,
             ssize_t repeat, int32_t token);
     virtual void cancelVibrate(int32_t deviceId, int32_t token);
 
@@ -379,11 +379,11 @@
 
         virtual void updateGlobalMetaState();
         virtual int32_t getGlobalMetaState();
-        virtual void disableVirtualKeysUntil(nsecs_t time);
-        virtual bool shouldDropVirtualKey(nsecs_t now,
+        virtual void disableVirtualKeysUntil(std::chrono::nanoseconds time);
+        virtual bool shouldDropVirtualKey(std::chrono::nanoseconds now,
                 InputDevice* device, int32_t keyCode, int32_t scanCode);
         virtual void fadePointer();
-        virtual void requestTimeoutAtTime(nsecs_t when);
+        virtual void requestTimeoutAtTime(std::chrono::nanoseconds when);
         virtual int32_t bumpGeneration();
         virtual InputReaderPolicyInterface* getPolicy();
         virtual InputListenerInterface* getListener();
@@ -412,12 +412,12 @@
     // low-level input event decoding and device management
     void processEventsLocked(const RawEvent* rawEvents, size_t count);
 
-    void addDeviceLocked(nsecs_t when, int32_t deviceId);
-    void removeDeviceLocked(nsecs_t when, int32_t deviceId);
+    void addDeviceLocked(std::chrono::nanoseconds when, int32_t deviceId);
+    void removeDeviceLocked(std::chrono::nanoseconds when, int32_t deviceId);
     void processEventsForDeviceLocked(int32_t deviceId, const RawEvent* rawEvents, size_t count);
-    void timeoutExpiredLocked(nsecs_t when);
+    void timeoutExpiredLocked(std::chrono::nanoseconds when);
 
-    void handleConfigurationChangedLocked(nsecs_t when);
+    void handleConfigurationChangedLocked(std::chrono::nanoseconds when);
 
     int32_t mGlobalMetaState;
     void updateGlobalMetaStateLocked();
@@ -430,13 +430,13 @@
 
     void getInputDevicesLocked(Vector<InputDeviceInfo>& outInputDevices);
 
-    nsecs_t mDisableVirtualKeysTimeout;
-    void disableVirtualKeysUntilLocked(nsecs_t time);
-    bool shouldDropVirtualKeyLocked(nsecs_t now,
+    std::chrono::nanoseconds mDisableVirtualKeysTimeout;
+    void disableVirtualKeysUntilLocked(std::chrono::nanoseconds time);
+    bool shouldDropVirtualKeyLocked(std::chrono::nanoseconds now,
             InputDevice* device, int32_t keyCode, int32_t scanCode);
 
-    nsecs_t mNextTimeout;
-    void requestTimeoutAtTimeLocked(nsecs_t when);
+    std::chrono::nanoseconds mNextTimeout;
+    void requestTimeoutAtTimeLocked(std::chrono::nanoseconds when);
 
     uint32_t mConfigurationChangesToRefresh;
     void refreshConfigurationLocked(uint32_t changes);
@@ -485,10 +485,10 @@
 
     void dump(String8& dump);
     void addMapper(InputMapper* mapper);
-    void configure(nsecs_t when, InputReaderConfiguration const* config, uint32_t changes);
-    void reset(nsecs_t when);
+    void configure(std::chrono::nanoseconds when, InputReaderConfiguration const* config, uint32_t changes);
+    void reset(std::chrono::nanoseconds when);
     void process(const RawEvent* rawEvents, size_t count);
-    void timeoutExpired(nsecs_t when);
+    void timeoutExpired(std::chrono::nanoseconds when);
 
     void getDeviceInfo(InputDeviceInfo* outDeviceInfo);
     int32_t getKeyCodeState(uint32_t sourceMask, int32_t keyCode);
@@ -496,7 +496,7 @@
     int32_t getSwitchState(uint32_t sourceMask, int32_t switchCode);
     bool markSupportedKeyCodes(uint32_t sourceMask, size_t numCodes,
             const int32_t* keyCodes, uint8_t* outFlags);
-    void vibrate(const nsecs_t* pattern, size_t patternSize, ssize_t repeat, int32_t token);
+    void vibrate(const std::chrono::nanoseconds* pattern, size_t patternSize, ssize_t repeat, int32_t token);
     void cancelVibrate(int32_t token);
 
     int32_t getMetaState();
@@ -505,7 +505,7 @@
 
     void bumpGeneration();
 
-    void notifyReset(nsecs_t when);
+    void notifyReset(std::chrono::nanoseconds when);
 
     inline const PropertyMap& getConfiguration() { return mConfiguration; }
     inline EventHubInterface* getEventHub() { return mContext->getEventHub(); }
@@ -897,17 +897,17 @@
     virtual uint32_t getSources() = 0;
     virtual void populateDeviceInfo(InputDeviceInfo* deviceInfo);
     virtual void dump(String8& dump);
-    virtual void configure(nsecs_t when, InputReaderConfiguration const* config, uint32_t changes);
-    virtual void reset(nsecs_t when);
+    virtual void configure(std::chrono::nanoseconds when, InputReaderConfiguration const* config, uint32_t changes);
+    virtual void reset(std::chrono::nanoseconds when);
     virtual void process(const RawEvent* rawEvent) = 0;
-    virtual void timeoutExpired(nsecs_t when);
+    virtual void timeoutExpired(std::chrono::nanoseconds when);
 
     virtual int32_t getKeyCodeState(uint32_t sourceMask, int32_t keyCode);
     virtual int32_t getScanCodeState(uint32_t sourceMask, int32_t scanCode);
     virtual int32_t getSwitchState(uint32_t sourceMask, int32_t switchCode);
     virtual bool markSupportedKeyCodes(uint32_t sourceMask, size_t numCodes,
             const int32_t* keyCodes, uint8_t* outFlags);
-    virtual void vibrate(const nsecs_t* pattern, size_t patternSize, ssize_t repeat,
+    virtual void vibrate(const std::chrono::nanoseconds* pattern, size_t patternSize, ssize_t repeat,
             int32_t token);
     virtual void cancelVibrate(int32_t token);
 
@@ -938,7 +938,7 @@
     virtual int32_t getSwitchState(uint32_t sourceMask, int32_t switchCode);
 
 private:
-    void processSwitch(nsecs_t when, int32_t switchCode, int32_t switchValue);
+    void processSwitch(std::chrono::nanoseconds when, int32_t switchCode, int32_t switchValue);
 };
 
 
@@ -951,20 +951,20 @@
     virtual void populateDeviceInfo(InputDeviceInfo* deviceInfo);
     virtual void process(const RawEvent* rawEvent);
 
-    virtual void vibrate(const nsecs_t* pattern, size_t patternSize, ssize_t repeat,
+    virtual void vibrate(const std::chrono::nanoseconds* pattern, size_t patternSize, ssize_t repeat,
             int32_t token);
     virtual void cancelVibrate(int32_t token);
-    virtual void timeoutExpired(nsecs_t when);
+    virtual void timeoutExpired(std::chrono::nanoseconds when);
     virtual void dump(String8& dump);
 
 private:
     bool mVibrating;
-    nsecs_t mPattern[MAX_VIBRATE_PATTERN_SIZE];
+    std::chrono::nanoseconds mPattern[MAX_VIBRATE_PATTERN_SIZE];
     size_t mPatternSize;
     ssize_t mRepeat;
     int32_t mToken;
     ssize_t mIndex;
-    nsecs_t mNextStepTime;
+    std::chrono::nanoseconds mNextStepTime;
 
     void nextStep();
     void stopVibrating();
@@ -979,9 +979,9 @@
     virtual uint32_t getSources();
     virtual void populateDeviceInfo(InputDeviceInfo* deviceInfo);
     virtual void dump(String8& dump);
-    virtual void configure(nsecs_t when, 
+    virtual void configure(std::chrono::nanoseconds when, 
         InputReaderConfiguration const* config, uint32_t changes);
-    virtual void reset(nsecs_t when);
+    virtual void reset(std::chrono::nanoseconds when);
     virtual void process(const RawEvent* rawEvent);
 
     virtual int32_t getKeyCodeState(uint32_t sourceMask, int32_t keyCode);
@@ -1004,7 +1004,7 @@
 
     Vector<KeyDown> mKeyDowns; // keys that are down
     int32_t mMetaState;
-    nsecs_t mDownTime; // time of most recent key down
+    std::chrono::nanoseconds mDownTime; // time of most recent key down
 
     int32_t mCurrentHidUsage; // most recent HID usage seen this packet, or 0 if none
 
@@ -1027,7 +1027,7 @@
 
     bool isKeyboardOrGamepadKey(int32_t scanCode);
 
-    void processKey(nsecs_t when, bool down, int32_t keyCode, int32_t scanCode,
+    void processKey(std::chrono::nanoseconds when, bool down, int32_t keyCode, int32_t scanCode,
             uint32_t policyFlags);
 
     ssize_t findKeyDown(int32_t scanCode);
@@ -1048,9 +1048,9 @@
     virtual uint32_t getSources();
     virtual void populateDeviceInfo(InputDeviceInfo* deviceInfo);
     virtual void dump(String8& dump);
-    virtual void configure(nsecs_t when, 
+    virtual void configure(std::chrono::nanoseconds when, 
         InputReaderConfiguration const* config, uint32_t changes);
-    virtual void reset(nsecs_t when);
+    virtual void reset(std::chrono::nanoseconds when);
     virtual void process(const RawEvent* rawEvent);
 
     virtual int32_t getScanCodeState(uint32_t sourceMask, int32_t scanCode);
@@ -1097,12 +1097,12 @@
     sp<PointerControllerInterface> mPointerController;
 
     int32_t mButtonState;
-    nsecs_t mDownTime;
+    std::chrono::nanoseconds mDownTime;
 
     void configureParameters();
     void dumpParameters(String8& dump);
 
-    void sync(nsecs_t when);
+    void sync(std::chrono::nanoseconds when);
 };
 
 
@@ -1114,9 +1114,9 @@
     virtual uint32_t getSources();
     virtual void populateDeviceInfo(InputDeviceInfo* deviceInfo);
     virtual void dump(String8& dump);
-    virtual void configure(nsecs_t when, 
+    virtual void configure(std::chrono::nanoseconds when, 
         InputReaderConfiguration const* config, uint32_t changes);
-    virtual void reset(nsecs_t when);
+    virtual void reset(std::chrono::nanoseconds when);
     virtual void process(const RawEvent* rawEvent);
 
     virtual int32_t getKeyCodeState(uint32_t sourceMask, int32_t keyCode);
@@ -1125,7 +1125,7 @@
             const int32_t* keyCodes, uint8_t* outFlags);
 
     virtual void fadePointer();
-    virtual void timeoutExpired(nsecs_t when);
+    virtual void timeoutExpired(std::chrono::nanoseconds when);
 
 protected:
     CursorButtonAccumulator mCursorButtonAccumulator;
@@ -1276,7 +1276,7 @@
     bool mSentHoverEnter;
 
     // The time the primary pointer last went down.
-    nsecs_t mDownTime;
+    std::chrono::nanoseconds mDownTime;
 
     // The pointer controller, or null if the device is not a pointer.
     sp<PointerControllerInterface> mPointerController;
@@ -1287,7 +1287,7 @@
     virtual void dumpParameters(String8& dump);
     virtual void configureRawPointerAxes();
     virtual void dumpRawPointerAxes(String8& dump);
-    virtual void configureSurface(nsecs_t when, bool* outResetNeeded);
+    virtual void configureSurface(std::chrono::nanoseconds when, bool* outResetNeeded);
     virtual void dumpSurface(String8& dump);
     virtual void configureVirtualKeys();
     virtual void dumpVirtualKeys(String8& dump);
@@ -1296,7 +1296,7 @@
     virtual void dumpCalibration(String8& dump);
     virtual bool hasStylus() const = 0;
 
-    virtual void syncTouch(nsecs_t when, bool* outHavePointerIds) = 0;
+    virtual void syncTouch(std::chrono::nanoseconds when, bool* outHavePointerIds) = 0;
     int32_t fetchNewPointerId();
 
 private:
@@ -1383,7 +1383,7 @@
     struct CurrentVirtualKeyState {
         bool down;
         bool ignored;
-        nsecs_t downTime;
+        std::chrono::nanoseconds downTime;
         int32_t keyCode;
         int32_t scanCode;
     } mCurrentVirtualKey;
@@ -1467,7 +1467,7 @@
         };
 
         // Time the first finger went down.
-        nsecs_t firstTouchTime;
+        std::chrono::nanoseconds firstTouchTime;
 
         // The active pointer id from the raw touch data.
         int32_t activeTouchId; // -1 if none
@@ -1489,19 +1489,19 @@
         PointerCoords lastGestureCoords[MAX_POINTERS];
 
         // Time the pointer gesture last went down.
-        nsecs_t downTime;
+        std::chrono::nanoseconds downTime;
 
         // Time when the pointer went down for a TAP.
-        nsecs_t tapDownTime;
+        std::chrono::nanoseconds tapDownTime;
 
         // Time when the pointer went up for a TAP.
-        nsecs_t tapUpTime;
+        std::chrono::nanoseconds tapUpTime;
 
         // Location of initial tap.
         float tapX, tapY;
 
         // Time we started waiting for quiescence.
-        nsecs_t quietTime;
+        std::chrono::nanoseconds quietTime;
 
         // Reference points for multitouch gestures.
         float referenceTouchX;    // reference touch X/Y coordinates in surface units
@@ -1524,26 +1524,26 @@
         VelocityTracker velocityTracker;
 
         void reset() {
-            firstTouchTime = LLONG_MIN;
+            firstTouchTime = std::chrono::nanoseconds(LLONG_MIN);
             activeTouchId = -1;
             activeGestureId = -1;
             currentGestureMode = NEUTRAL;
             currentGestureIds.clear();
             lastGestureMode = NEUTRAL;
             lastGestureIds.clear();
-            downTime = 0;
+            downTime = std::chrono::nanoseconds(0);
             velocityTracker.clear();
             resetTap();
             resetQuietTime();
         }
 
         void resetTap() {
-            tapDownTime = LLONG_MIN;
-            tapUpTime = LLONG_MIN;
+            tapDownTime = std::chrono::nanoseconds(LLONG_MIN);
+            tapUpTime = std::chrono::nanoseconds(LLONG_MIN);
         }
 
         void resetQuietTime() {
-            quietTime = LLONG_MIN;
+            quietTime = std::chrono::nanoseconds(LLONG_MIN);
         }
     } mPointerGesture;
 
@@ -1560,7 +1560,7 @@
         bool hovering;
 
         // Time the pointer last went down.
-        nsecs_t downTime;
+        std::chrono::nanoseconds downTime;
 
         void reset() {
             currentCoords.clear();
@@ -1569,7 +1569,7 @@
             lastProperties.clear();
             down = false;
             hovering = false;
-            downTime = 0;
+            downTime = std::chrono::nanoseconds(0);
         }
     } mPointerSimple;
 
@@ -1578,52 +1578,52 @@
     VelocityControl mWheelXVelocityControl;
     VelocityControl mWheelYVelocityControl;
 
-    void sync(nsecs_t when);
+    void sync(std::chrono::nanoseconds when);
 
-    bool consumeRawTouches(nsecs_t when, uint32_t policyFlags);
-    void dispatchVirtualKey(nsecs_t when, uint32_t policyFlags,
+    bool consumeRawTouches(std::chrono::nanoseconds when, uint32_t policyFlags);
+    void dispatchVirtualKey(std::chrono::nanoseconds when, uint32_t policyFlags,
             int32_t keyEventAction, int32_t keyEventFlags);
 
-    void dispatchTouches(nsecs_t when, uint32_t policyFlags);
-    void dispatchHoverExit(nsecs_t when, uint32_t policyFlags);
-    void dispatchHoverEnterAndMove(nsecs_t when, uint32_t policyFlags);
+    void dispatchTouches(std::chrono::nanoseconds when, uint32_t policyFlags);
+    void dispatchHoverExit(std::chrono::nanoseconds when, uint32_t policyFlags);
+    void dispatchHoverEnterAndMove(std::chrono::nanoseconds when, uint32_t policyFlags);
     void cookPointerData();
 
-    void dispatchPointerUsage(nsecs_t when, uint32_t policyFlags, PointerUsage pointerUsage);
-    void abortPointerUsage(nsecs_t when, uint32_t policyFlags);
+    void dispatchPointerUsage(std::chrono::nanoseconds when, uint32_t policyFlags, PointerUsage pointerUsage);
+    void abortPointerUsage(std::chrono::nanoseconds when, uint32_t policyFlags);
 
-    void dispatchPointerGestures(nsecs_t when, uint32_t policyFlags, bool isTimeout);
-    void abortPointerGestures(nsecs_t when, uint32_t policyFlags);
-    bool preparePointerGestures(nsecs_t when,
+    void dispatchPointerGestures(std::chrono::nanoseconds when, uint32_t policyFlags, bool isTimeout);
+    void abortPointerGestures(std::chrono::nanoseconds when, uint32_t policyFlags);
+    bool preparePointerGestures(std::chrono::nanoseconds when,
             bool* outCancelPreviousGesture, bool* outFinishPreviousGesture,
             bool isTimeout);
 
-    void dispatchPointerStylus(nsecs_t when, uint32_t policyFlags);
-    void abortPointerStylus(nsecs_t when, uint32_t policyFlags);
-
-    void dispatchPointerMouse(nsecs_t when, uint32_t policyFlags);
-    void abortPointerMouse(nsecs_t when, uint32_t policyFlags);
-
-    void dispatchPointerSimple(nsecs_t when, uint32_t policyFlags,
+    void dispatchPointerStylus(std::chrono::nanoseconds when, uint32_t policyFlags);
+    void abortPointerStylus(std::chrono::nanoseconds when, uint32_t policyFlags);
+
+    void dispatchPointerMouse(std::chrono::nanoseconds when, uint32_t policyFlags);
+    void abortPointerMouse(std::chrono::nanoseconds when, uint32_t policyFlags);
+
+    void dispatchPointerSimple(std::chrono::nanoseconds when, uint32_t policyFlags,
             bool down, bool hovering);
-    void abortPointerSimple(nsecs_t when, uint32_t policyFlags);
+    void abortPointerSimple(std::chrono::nanoseconds when, uint32_t policyFlags);
 
     // Dispatches a motion event.
     // If the changedId is >= 0 and the action is POINTER_DOWN or POINTER_UP, the
     // method will take care of setting the index and transmuting the action to DOWN or UP
     // it is the first / last pointer to go down / up.
-    void dispatchMotion(nsecs_t when, uint32_t policyFlags, uint32_t source,
+    void dispatchMotion(std::chrono::nanoseconds 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,
-            int32_t changedId, float xPrecision, float yPrecision, nsecs_t downTime);
-    void dispatchMotion(nsecs_t when, uint32_t policyFlags, uint32_t source,
+            int32_t changedId, float xPrecision, float yPrecision, std::chrono::nanoseconds downTime);
+    void dispatchMotion(std::chrono::nanoseconds 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);
+            int32_t changedId, float xPrecision, float yPrecision, std::chrono::nanoseconds downTime);
 
     // Updates pointer coords and properties for pointers that have moved.
     // Returns true if any of them changed.
@@ -1644,11 +1644,11 @@
     SingleTouchInputMapper(InputDevice* device);
     virtual ~SingleTouchInputMapper();
 
-    virtual void reset(nsecs_t when);
+    virtual void reset(std::chrono::nanoseconds when);
     virtual void process(const RawEvent* rawEvent);
 
 protected:
-    virtual void syncTouch(nsecs_t when, bool* outHavePointerIds);
+    virtual void syncTouch(std::chrono::nanoseconds when, bool* outHavePointerIds);
     virtual void configureRawPointerAxes();
     virtual bool hasStylus() const;
 
@@ -1662,11 +1662,11 @@
     MultiTouchInputMapper(InputDevice* device);
     virtual ~MultiTouchInputMapper();
 
-    virtual void reset(nsecs_t when);
+    virtual void reset(std::chrono::nanoseconds when);
     virtual void process(const RawEvent* rawEvent);
 
 protected:
-    virtual void syncTouch(nsecs_t when, bool* outHavePointerIds);
+    virtual void syncTouch(std::chrono::nanoseconds when, bool* outHavePointerIds);
     virtual void configureRawPointerAxes();
     virtual bool hasStylus() const;
 
@@ -1687,9 +1687,9 @@
     virtual uint32_t getSources();
     virtual void populateDeviceInfo(InputDeviceInfo* deviceInfo);
     virtual void dump(String8& dump);
-    virtual void configure(nsecs_t when,
+    virtual void configure(std::chrono::nanoseconds when,
         InputReaderConfiguration const* config, uint32_t changes);
-    virtual void reset(nsecs_t when);
+    virtual void reset(std::chrono::nanoseconds when);
     virtual void process(const RawEvent* rawEvent);
 
 private:
@@ -1745,7 +1745,7 @@
     // Axes indexed by raw ABS_* axis index.
     KeyedVector<int32_t, Axis> mAxes;
 
-    void sync(nsecs_t when, bool force);
+    void sync(std::chrono::nanoseconds when, bool force);
 
     bool haveAxis(int32_t axisId);
     void pruneAxes(bool ignoreExplicitlyMappedAxes);

=== modified file '3rd_party/android-input/android/frameworks/base/services/input/InputTransport.cpp'
--- 3rd_party/android-input/android/frameworks/base/services/input/InputTransport.cpp	2014-03-06 06:05:17 +0000
+++ 3rd_party/android-input/android/frameworks/base/services/input/InputTransport.cpp	2015-02-09 23:59:09 +0000
@@ -39,18 +39,18 @@
 static const size_t SOCKET_BUFFER_SIZE = 32 * 1024;
 
 // Nanoseconds per milliseconds.
-static const nsecs_t NANOS_PER_MS = 1000000;
+static constexpr const std::chrono::nanoseconds NANOS_PER_MS = std::chrono::nanoseconds(1000000);
 
 // Latency added during resampling.  A few milliseconds doesn't hurt much but
 // reduces the impact of mispredicted touch positions.
-static const nsecs_t RESAMPLE_LATENCY = 5 * NANOS_PER_MS;
+static constexpr const std::chrono::nanoseconds RESAMPLE_LATENCY = std::chrono::nanoseconds(5 * NANOS_PER_MS);
 
 // Minimum time difference between consecutive samples before attempting to resample.
-static const nsecs_t RESAMPLE_MIN_DELTA = 2 * NANOS_PER_MS;
+static constexpr const std::chrono::nanoseconds RESAMPLE_MIN_DELTA = std::chrono::nanoseconds(2 * NANOS_PER_MS);
 
 // Maximum time to predict forward from the last known state, to avoid predicting too
 // far into the future.  This time is further bounded by 50% of the last time delta.
-static const nsecs_t RESAMPLE_MAX_PREDICTION = 8 * NANOS_PER_MS;
+static constexpr const std::chrono::nanoseconds RESAMPLE_MAX_PREDICTION = std::chrono::nanoseconds(8 * NANOS_PER_MS);
 
 template<typename T>
 inline static T min(const T& a, const T& b) {
@@ -236,8 +236,8 @@
         int32_t scanCode,
         int32_t metaState,
         int32_t repeatCount,
-        nsecs_t downTime,
-        nsecs_t eventTime) {
+        std::chrono::nanoseconds downTime,
+        std::chrono::nanoseconds eventTime) {
 #if DEBUG_TRANSPORT_ACTIONS
     ALOGD("channel '%s' publisher ~ publishKeyEvent: seq=%u, deviceId=%d, source=0x%x, "
             "action=0x%x, flags=0x%x, keyCode=%d, scanCode=%d, metaState=0x%x, repeatCount=%d,"
@@ -263,8 +263,8 @@
     msg.body.key.scanCode = scanCode;
     msg.body.key.metaState = metaState;
     msg.body.key.repeatCount = repeatCount;
-    msg.body.key.downTime = downTime;
-    msg.body.key.eventTime = eventTime;
+    msg.body.key.downTime = downTime.count();
+    msg.body.key.eventTime = eventTime.count();
     return mChannel->sendMessage(&msg);
 }
 
@@ -281,8 +281,8 @@
         float yOffset,
         float xPrecision,
         float yPrecision,
-        nsecs_t downTime,
-        nsecs_t eventTime,
+        std::chrono::nanoseconds downTime,
+        std::chrono::nanoseconds eventTime,
         size_t pointerCount,
         const PointerProperties* pointerProperties,
         const PointerCoords* pointerCoords) {
@@ -322,8 +322,8 @@
     msg.body.motion.yOffset = yOffset;
     msg.body.motion.xPrecision = xPrecision;
     msg.body.motion.yPrecision = yPrecision;
-    msg.body.motion.downTime = downTime;
-    msg.body.motion.eventTime = eventTime;
+    msg.body.motion.downTime = downTime.count();
+    msg.body.motion.eventTime = eventTime.count();
     msg.body.motion.pointerCount = pointerCount;
     for (size_t i = 0; i < pointerCount; i++) {
         msg.body.motion.pointers[i].properties.copyFrom(pointerProperties[i]);
@@ -381,7 +381,7 @@
 }
 
 status_t InputConsumer::consume(InputEventFactoryInterface* factory,
-        bool consumeBatches, nsecs_t frameTime, uint32_t* outSeq, InputEvent** outEvent) {
+        bool consumeBatches, std::chrono::nanoseconds frameTime, uint32_t* outSeq, InputEvent** outEvent) {
 #if DEBUG_TRANSPORT_ACTIONS
     ALOGD("channel '%s' consumer ~ consume: consumeBatches=%s, frameTime=%lld",
         c_str(mChannel->getName()), consumeBatches ? "true" : "false", frameTime);
@@ -498,18 +498,18 @@
 }
 
 status_t InputConsumer::consumeBatch(InputEventFactoryInterface* factory,
-        nsecs_t frameTime, uint32_t* outSeq, InputEvent** outEvent) {
+        std::chrono::nanoseconds frameTime, uint32_t* outSeq, InputEvent** outEvent) {
     status_t result;
     for (size_t i = mBatches.size(); i-- > 0; ) {
         Batch& batch = mBatches.editItemAt(i);
-        if (frameTime < 0) {
+        if (frameTime < std::chrono::nanoseconds(0)) {
             result = consumeSamples(factory, batch, batch.samples.size(),
                     outSeq, outEvent);
             mBatches.removeAt(i);
             return result;
         }
 
-        nsecs_t sampleTime = frameTime - RESAMPLE_LATENCY;
+        std::chrono::nanoseconds sampleTime = frameTime - RESAMPLE_LATENCY;
         ssize_t split = findSampleNoLaterThan(batch, sampleTime);
         if (split < 0) {
             continue;
@@ -567,7 +567,7 @@
 
     int32_t deviceId = msg->body.motion.deviceId;
     int32_t source = msg->body.motion.source;
-    nsecs_t eventTime = msg->body.motion.eventTime;
+    std::chrono::nanoseconds eventTime = std::chrono::nanoseconds(msg->body.motion.eventTime);
 
     // Update the touch state history to incorporate the new input message.
     // If the message is in the past relative to the most recently produced resampled
@@ -660,7 +660,7 @@
     }
 }
 
-void InputConsumer::resampleTouchState(nsecs_t sampleTime, MotionEvent* event,
+void InputConsumer::resampleTouchState(std::chrono::nanoseconds sampleTime, MotionEvent* event,
     const InputMessage* next) {
     if (!mResampleTouch
             || !(event->getSource() & AINPUT_SOURCE_CLASS_POINTER)
@@ -706,26 +706,26 @@
         // So current->eventTime <= sampleTime <= future.eventTime.
         future.initializeFrom(next);
         other = &future;
-        nsecs_t delta = future.eventTime - current->eventTime;
+        std::chrono::nanoseconds delta = future.eventTime - current->eventTime;
         if (delta < RESAMPLE_MIN_DELTA) {
 #if DEBUG_RESAMPLING
             ALOGD("Not resampled, delta time is %lld ns.", delta);
 #endif
             return;
         }
-        alpha = float(sampleTime - current->eventTime) / delta;
+        alpha = (float)((sampleTime - current->eventTime).count()) / delta.count();
     } else if (touchState.historySize >= 2) {
         // Extrapolate future sample using current sample and past sample.
         // So other->eventTime <= current->eventTime <= sampleTime.
         other = touchState.getHistory(1);
-        nsecs_t delta = current->eventTime - other->eventTime;
+        std::chrono::nanoseconds delta = current->eventTime - other->eventTime;
         if (delta < RESAMPLE_MIN_DELTA) {
 #if DEBUG_RESAMPLING
             ALOGD("Not resampled, delta time is %lld ns.", delta);
 #endif
             return;
         }
-        nsecs_t maxPredict = current->eventTime + min(delta / 2, RESAMPLE_MAX_PREDICTION);
+        std::chrono::nanoseconds maxPredict = current->eventTime + std::chrono::nanoseconds(min(delta.count()/2, RESAMPLE_MAX_PREDICTION.count()));
         if (sampleTime > maxPredict) {
 #if DEBUG_RESAMPLING
             ALOGD("Sample time is too far in the future, adjusting prediction "
@@ -734,7 +734,7 @@
 #endif
             sampleTime = maxPredict;
         }
-        alpha = float(current->eventTime - sampleTime) / delta;
+        alpha = (float)((current->eventTime - sampleTime).count()) / delta.count();
     } else {
 #if DEBUG_RESAMPLING
         ALOGD("Not resampled, insufficient data.");
@@ -877,8 +877,8 @@
             msg->body.key.scanCode,
             msg->body.key.metaState,
             msg->body.key.repeatCount,
-            msg->body.key.downTime,
-            msg->body.key.eventTime);
+            std::chrono::nanoseconds(msg->body.key.downTime),
+            std::chrono::nanoseconds(msg->body.key.eventTime));
 }
 
 void InputConsumer::initializeMotionEvent(MotionEvent* event, const InputMessage* msg) {
@@ -902,8 +902,8 @@
             msg->body.motion.yOffset,
             msg->body.motion.xPrecision,
             msg->body.motion.yPrecision,
-            msg->body.motion.downTime,
-            msg->body.motion.eventTime,
+            std::chrono::nanoseconds(msg->body.motion.downTime),
+            std::chrono::nanoseconds(msg->body.motion.eventTime),
             pointerCount,
             pointerProperties,
             pointerCoords);
@@ -917,7 +917,7 @@
     }
 
     event->setMetaState(event->getMetaState() | msg->body.motion.metaState);
-    event->addSample(msg->body.motion.eventTime, pointerCoords);
+    event->addSample(std::chrono::nanoseconds(msg->body.motion.eventTime), pointerCoords);
 }
 
 bool InputConsumer::canAddSample(const Batch& batch, const InputMessage *msg) {
@@ -936,11 +936,11 @@
     return true;
 }
 
-ssize_t InputConsumer::findSampleNoLaterThan(const Batch& batch, nsecs_t time) {
+ssize_t InputConsumer::findSampleNoLaterThan(const Batch& batch, std::chrono::nanoseconds time) {
     size_t numSamples = batch.samples.size();
     size_t index = 0;
     while (index < numSamples
-            && batch.samples.itemAt(index).body.motion.eventTime <= time) {
+           && batch.samples.itemAt(index).body.motion.eventTime <= time.count()) {
         index += 1;
     }
     return ssize_t(index) - 1;

=== modified file '3rd_party/android-input/android/frameworks/base/services/input/InputWindow.h'
--- 3rd_party/android-input/android/frameworks/base/services/input/InputWindow.h	2013-06-28 17:59:49 +0000
+++ 3rd_party/android-input/android/frameworks/base/services/input/InputWindow.h	2015-02-09 23:59:09 +0000
@@ -115,7 +115,7 @@
     String8 name;
     int32_t layoutParamsFlags;
     int32_t layoutParamsType;
-    nsecs_t dispatchingTimeout;
+    std::chrono::nanoseconds dispatchingTimeout;
     int32_t frameLeft;
     int32_t frameTop;
     int32_t frameRight;
@@ -174,7 +174,7 @@
         return mInfo ? mInfo->name : String8("<invalid>");
     }
 
-    inline nsecs_t getDispatchingTimeout(nsecs_t defaultValue) const {
+    inline std::chrono::nanoseconds getDispatchingTimeout(std::chrono::nanoseconds defaultValue) const {
         return mInfo ? mInfo->dispatchingTimeout : defaultValue;
     }
 

=== modified file '3rd_party/android-input/android/frameworks/base/services/input/KeyCharacterMap.cpp'
--- 3rd_party/android-input/android/frameworks/base/services/input/KeyCharacterMap.cpp	2013-05-03 16:38:07 +0000
+++ 3rd_party/android-input/android/frameworks/base/services/input/KeyCharacterMap.cpp	2015-02-09 23:59:09 +0000
@@ -141,12 +141,12 @@
         status = NO_MEMORY;
     } else {
 #if DEBUG_PARSER_PERFORMANCE
-        nsecs_t startTime = systemTime(SYSTEM_TIME_MONOTONIC);
+        std::chrono::nanoseconds startTime = systemTime(SYSTEM_TIME_MONOTONIC);
 #endif
         Parser parser(map.get(), tokenizer, format);
         status = parser.parse();
 #if DEBUG_PARSER_PERFORMANCE
-        nsecs_t elapsedTime = systemTime(SYSTEM_TIME_MONOTONIC) - startTime;
+        std::chrono::nanoseconds elapsedTime = systemTime(SYSTEM_TIME_MONOTONIC) - startTime;
         ALOGD("Parsed key character map file '%s' %d lines in %0.3fms.",
             c_str(tokenizer->getFilename()), tokenizer->getLineNumber(),
                 elapsedTime / 1000000.0);
@@ -294,7 +294,7 @@
 
 bool KeyCharacterMap::getEvents(int32_t deviceId, const char16_t* chars, size_t numChars,
         Vector<KeyEvent>& outEvents) const {
-    nsecs_t now = systemTime(SYSTEM_TIME_MONOTONIC);
+    std::chrono::nanoseconds now = systemTime(SYSTEM_TIME_MONOTONIC);
 
     for (size_t i = 0; i < numChars; i++) {
         int32_t keyCode, metaState;
@@ -439,7 +439,7 @@
 }
 
 void KeyCharacterMap::addKey(Vector<KeyEvent>& outEvents,
-        int32_t deviceId, int32_t keyCode, int32_t metaState, bool down, nsecs_t time) {
+        int32_t deviceId, int32_t keyCode, int32_t metaState, bool down, std::chrono::nanoseconds time) {
     outEvents.push();
     KeyEvent& event = outEvents.editTop();
     event.initialize(deviceId, AINPUT_SOURCE_KEYBOARD,
@@ -448,7 +448,7 @@
 }
 
 void KeyCharacterMap::addMetaKeys(Vector<KeyEvent>& outEvents,
-        int32_t deviceId, int32_t metaState, bool down, nsecs_t time,
+        int32_t deviceId, int32_t metaState, bool down, std::chrono::nanoseconds time,
         int32_t* currentMetaState) {
     // Add and remove meta keys symmetrically.
     if (down) {
@@ -513,7 +513,7 @@
 }
 
 bool KeyCharacterMap::addSingleEphemeralMetaKey(Vector<KeyEvent>& outEvents,
-        int32_t deviceId, int32_t metaState, bool down, nsecs_t time,
+        int32_t deviceId, int32_t metaState, bool down, std::chrono::nanoseconds time,
         int32_t keyCode, int32_t keyMetaState,
         int32_t* currentMetaState) {
     if ((metaState & keyMetaState) == keyMetaState) {
@@ -525,7 +525,7 @@
 }
 
 void KeyCharacterMap::addDoubleEphemeralMetaKey(Vector<KeyEvent>& outEvents,
-        int32_t deviceId, int32_t metaState, bool down, nsecs_t time,
+        int32_t deviceId, int32_t metaState, bool down, std::chrono::nanoseconds time,
         int32_t leftKeyCode, int32_t leftKeyMetaState,
         int32_t rightKeyCode, int32_t rightKeyMetaState,
         int32_t eitherKeyMetaState,
@@ -543,7 +543,7 @@
 }
 
 void KeyCharacterMap::addLockedMetaKey(Vector<KeyEvent>& outEvents,
-        int32_t deviceId, int32_t metaState, nsecs_t time,
+        int32_t deviceId, int32_t metaState, std::chrono::nanoseconds time,
         int32_t keyCode, int32_t keyMetaState,
         int32_t* currentMetaState) {
     if ((metaState & keyMetaState) == keyMetaState) {

=== modified file '3rd_party/android-input/android/frameworks/base/services/input/KeyLayoutMap.cpp'
--- 3rd_party/android-input/android/frameworks/base/services/input/KeyLayoutMap.cpp	2013-05-03 16:38:07 +0000
+++ 3rd_party/android-input/android/frameworks/base/services/input/KeyLayoutMap.cpp	2015-02-09 23:59:09 +0000
@@ -57,12 +57,12 @@
 	status = NO_MEMORY;
     } else {
 #if DEBUG_PARSER_PERFORMANCE
-	nsecs_t startTime = systemTime(SYSTEM_TIME_MONOTONIC);
+	std::chrono::nanoseconds startTime = systemTime(SYSTEM_TIME_MONOTONIC);
 #endif
 	Parser parser(map.get(), tokenizer);
 	status = parser.parse();
 #if DEBUG_PARSER_PERFORMANCE
-	nsecs_t elapsedTime = systemTime(SYSTEM_TIME_MONOTONIC) - startTime;
+	std::chrono::nanoseconds elapsedTime = systemTime(SYSTEM_TIME_MONOTONIC) - startTime;
 	ALOGD("Parsed key layout map file '%s' %d lines in %0.3fms.",
 	      tokenizer->getFilename().string(), tokenizer->getLineNumber(),
 	      elapsedTime / 1000000.0);

=== modified file '3rd_party/android-input/android/frameworks/base/services/input/VelocityControl.cpp'
--- 3rd_party/android-input/android/frameworks/base/services/input/VelocityControl.cpp	2014-03-06 06:05:17 +0000
+++ 3rd_party/android-input/android/frameworks/base/services/input/VelocityControl.cpp	2015-02-09 23:59:09 +0000
@@ -30,7 +30,7 @@
 
 // --- VelocityControl ---
 
-const nsecs_t VelocityControl::STOP_TIME;
+const constexpr std::chrono::nanoseconds VelocityControl::STOP_TIME;
 
 VelocityControl::VelocityControl() {
     reset();
@@ -43,13 +43,13 @@
 }
 
 void VelocityControl::reset() {
-    mLastMovementTime = LLONG_MIN;
+    mLastMovementTime = std::chrono::nanoseconds(LLONG_MIN);
     mRawPosition.x = 0;
     mRawPosition.y = 0;
     mVelocityTracker.clear();
 }
 
-void VelocityControl::move(nsecs_t eventTime, float* deltaX, float* deltaY) {
+void VelocityControl::move(std::chrono::nanoseconds eventTime, float* deltaX, float* deltaY) {
     if ((deltaX && *deltaX) || (deltaY && *deltaY)) {
         if (eventTime >= mLastMovementTime + STOP_TIME) {
 #if DEBUG_ACCELERATION

=== modified file '3rd_party/android-input/android/frameworks/base/services/input/VelocityTracker.cpp'
--- 3rd_party/android-input/android/frameworks/base/services/input/VelocityTracker.cpp	2014-03-06 06:05:17 +0000
+++ 3rd_party/android-input/android/frameworks/base/services/input/VelocityTracker.cpp	2015-02-09 23:59:09 +0000
@@ -37,13 +37,13 @@
 namespace android {
 
 // Nanoseconds per milliseconds.
-static const nsecs_t NANOS_PER_MS = 1000000;
+static const int64_t NANOS_PER_MS = 1000000;
 
 // Threshold for determining that a pointer has stopped moving.
 // Some input devices do not send ACTION_MOVE events in the case where a pointer has
 // stopped.  We need to detect this case so that we can accurately predict the
 // velocity after the pointer starts moving again.
-static const nsecs_t ASSUME_POINTER_STOPPED_TIME = 40 * NANOS_PER_MS;
+static constexpr const std::chrono::nanoseconds ASSUME_POINTER_STOPPED_TIME = std::chrono::nanoseconds(40 * NANOS_PER_MS);
 
 
 static float vectorDot(const float* a, const float* b, uint32_t m) {
@@ -218,7 +218,7 @@
     mStrategy->clearPointers(ids);
 }
 
-void VelocityTracker::addMovement(nsecs_t eventTime, const IntSet &ids, const Position* positions) {
+void VelocityTracker::addMovement(std::chrono::nanoseconds eventTime, const IntSet &ids, const Position* positions) {
     if (!(mCurrentPointerIds & ids).isEmpty()
             && eventTime >= mLastEventTime + ASSUME_POINTER_STOPPED_TIME) {
 #if DEBUG_VELOCITY
@@ -305,7 +305,7 @@
         pointerIndex[i] = ids.indexOf(event->getPointerId(i));
     }
 
-    nsecs_t eventTime;
+    std::chrono::nanoseconds eventTime;
     Position positions[pointerCount];
 
     size_t historySize = event->getHistorySize();
@@ -347,7 +347,7 @@
 
 // --- LeastSquaresVelocityTrackerStrategy ---
 
-const nsecs_t LeastSquaresVelocityTrackerStrategy::HORIZON;
+constexpr const std::chrono::nanoseconds LeastSquaresVelocityTrackerStrategy::HORIZON;
 const uint32_t LeastSquaresVelocityTrackerStrategy::HISTORY_SIZE;
 
 LeastSquaresVelocityTrackerStrategy::LeastSquaresVelocityTrackerStrategy(
@@ -368,7 +368,7 @@
     mMovements[mIndex].ids.remove(ids);
 }
 
-void LeastSquaresVelocityTrackerStrategy::addMovement(nsecs_t eventTime, const IntSet &ids,
+void LeastSquaresVelocityTrackerStrategy::addMovement(std::chrono::nanoseconds eventTime, const IntSet &ids,
         const VelocityTracker::Position* positions) {
     if (++mIndex == HISTORY_SIZE) {
         mIndex = 0;
@@ -567,7 +567,7 @@
             break;
         }
 
-        nsecs_t age = newestMovement.eventTime - movement.eventTime;
+        std::chrono::nanoseconds age = newestMovement.eventTime - movement.eventTime;
         if (age > HORIZON) {
             break;
         }
@@ -576,7 +576,7 @@
         x[m] = position.x;
         y[m] = position.y;
         w[m] = chooseWeight(index);
-        time[m] = -age * 0.000000001f;
+        time[m] = -age.count() * 0.000000001f;
         index = (index == 0 ? HISTORY_SIZE : index) - 1;
     } while (++m < HISTORY_SIZE);
 
@@ -628,7 +628,7 @@
             return 1.0f;
         }
         uint32_t nextIndex = (index + 1) % HISTORY_SIZE;
-        float deltaMillis = (mMovements[nextIndex].eventTime- mMovements[index].eventTime)
+        float deltaMillis = (mMovements[nextIndex].eventTime- mMovements[index].eventTime).count()
                 * 0.000001f;
         if (deltaMillis < 0) {
             return 0.5f;
@@ -645,7 +645,7 @@
         //   age 10ms: 1.0
         //   age 50ms: 1.0
         //   age 60ms: 0.5
-        float ageMillis = (mMovements[mIndex].eventTime - mMovements[index].eventTime)
+        float ageMillis = (mMovements[mIndex].eventTime - mMovements[index].eventTime).count()
                 * 0.000001f;
         if (ageMillis < 0) {
             return 0.5f;
@@ -667,7 +667,7 @@
         //   age   0ms: 1.0
         //   age  50ms: 1.0
         //   age 100ms: 0.5
-        float ageMillis = (mMovements[mIndex].eventTime - mMovements[index].eventTime)
+        float ageMillis = (mMovements[mIndex].eventTime - mMovements[index].eventTime).count()
                 * 0.000001f;
         if (ageMillis < 50) {
             return 1.0f;
@@ -702,7 +702,7 @@
     mPointerIds.remove(ids);
 }
 
-void IntegratingVelocityTrackerStrategy::addMovement(nsecs_t eventTime, const IntSet &ids,
+void IntegratingVelocityTrackerStrategy::addMovement(std::chrono::nanoseconds eventTime, const IntSet &ids,
         const VelocityTracker::Position* positions) {
 
     {
@@ -741,7 +741,7 @@
 }
 
 void IntegratingVelocityTrackerStrategy::initState(State& state,
-        nsecs_t eventTime, float xpos, float ypos) const {
+        std::chrono::nanoseconds eventTime, float xpos, float ypos) const {
     state.updateTime = eventTime;
     state.degree = 0;
 
@@ -754,15 +754,15 @@
 }
 
 void IntegratingVelocityTrackerStrategy::updateState(State& state,
-        nsecs_t eventTime, float xpos, float ypos) const {
-    const nsecs_t MIN_TIME_DELTA = 2 * NANOS_PER_MS;
+        std::chrono::nanoseconds eventTime, float xpos, float ypos) const {
+    const std::chrono::nanoseconds MIN_TIME_DELTA = std::chrono::nanoseconds(2 * NANOS_PER_MS);
     const float FILTER_TIME_CONSTANT = 0.010f; // 10 milliseconds
 
     if (eventTime <= state.updateTime + MIN_TIME_DELTA) {
         return;
     }
 
-    float dt = (eventTime - state.updateTime) * 0.000000001f;
+    float dt = (eventTime - state.updateTime).count() * 0.000000001f;
     state.updateTime = eventTime;
 
     float xvel = (xpos - state.xpos) / dt;
@@ -811,9 +811,9 @@
 
 // --- LegacyVelocityTrackerStrategy ---
 
-const nsecs_t LegacyVelocityTrackerStrategy::HORIZON;
+constexpr const std::chrono::nanoseconds LegacyVelocityTrackerStrategy::HORIZON;
 const uint32_t LegacyVelocityTrackerStrategy::HISTORY_SIZE;
-const nsecs_t LegacyVelocityTrackerStrategy::MIN_DURATION;
+constexpr const std::chrono::nanoseconds LegacyVelocityTrackerStrategy::MIN_DURATION;
 
 LegacyVelocityTrackerStrategy::LegacyVelocityTrackerStrategy() {
     clear();
@@ -831,7 +831,7 @@
     mMovements[mIndex].ids.remove(ids);
 }
 
-void LegacyVelocityTrackerStrategy::addMovement(nsecs_t eventTime, const IntSet &ids,
+void LegacyVelocityTrackerStrategy::addMovement(std::chrono::nanoseconds eventTime, const IntSet &ids,
         const VelocityTracker::Position* positions) {
     if (++mIndex == HISTORY_SIZE) {
         mIndex = 0;
@@ -853,7 +853,7 @@
     }
 
     // Find the oldest sample that contains the pointer and that is not older than HORIZON.
-    nsecs_t minTime = newestMovement.eventTime - HORIZON;
+    std::chrono::nanoseconds minTime = newestMovement.eventTime - HORIZON;
     uint32_t oldestIndex = mIndex;
     uint32_t numTouches = 1;
     do {
@@ -883,21 +883,21 @@
     uint32_t samplesUsed = 0;
     const Movement& oldestMovement = mMovements[oldestIndex];
     const VelocityTracker::Position& oldestPosition = oldestMovement.getPosition(id);
-    nsecs_t lastDuration = 0;
+    std::chrono::nanoseconds lastDuration = std::chrono::nanoseconds(0);
 
     while (numTouches-- > 1) {
         if (++index == HISTORY_SIZE) {
             index = 0;
         }
         const Movement& movement = mMovements[index];
-        nsecs_t duration = movement.eventTime - oldestMovement.eventTime;
+        std::chrono::nanoseconds duration = movement.eventTime - oldestMovement.eventTime;
 
         // If the duration between samples is small, we may significantly overestimate
         // the velocity.  Consequently, we impose a minimum duration constraint on the
         // samples that we include in the calculation.
         if (duration >= MIN_DURATION) {
             const VelocityTracker::Position& position = movement.getPosition(id);
-            float scale = 1000000000.0f / duration; // one over time delta in seconds
+            float scale = 1000000000.0f / duration.count(); // one over time delta in seconds
             float vx = (position.x - oldestPosition.x) * scale;
             float vy = (position.y - oldestPosition.y) * scale;
             accumVx = (accumVx * lastDuration + vx * duration) / (duration + lastDuration);

=== modified file '3rd_party/android-input/android/frameworks/base/services/input/VirtualKeyMap.cpp'
--- 3rd_party/android-input/android/frameworks/base/services/input/VirtualKeyMap.cpp	2013-05-03 16:38:07 +0000
+++ 3rd_party/android-input/android/frameworks/base/services/input/VirtualKeyMap.cpp	2015-02-09 23:59:09 +0000
@@ -59,12 +59,12 @@
             status = NO_MEMORY;
         } else {
 #if DEBUG_PARSER_PERFORMANCE
-            nsecs_t startTime = systemTime(SYSTEM_TIME_MONOTONIC);
+            std::chrono::nanoseconds startTime = systemTime(SYSTEM_TIME_MONOTONIC);
 #endif
             Parser parser(map, tokenizer);
             status = parser.parse();
 #if DEBUG_PARSER_PERFORMANCE
-            nsecs_t elapsedTime = systemTime(SYSTEM_TIME_MONOTONIC) - startTime;
+            std::chrono::nanoseconds elapsedTime = systemTime(SYSTEM_TIME_MONOTONIC) - startTime;
             ALOGD("Parsed key character map file '%s' %d lines in %0.3fms.",
                 c_str(tokenizer->getFilename()), tokenizer->getLineNumber(),
                     elapsedTime / 1000000.0);

=== modified file '3rd_party/android-input/android/frameworks/native/include/utils/Looper.h'
--- 3rd_party/android-input/android/frameworks/native/include/utils/Looper.h	2013-05-03 16:38:07 +0000
+++ 3rd_party/android-input/android/frameworks/native/include/utils/Looper.h	2015-02-09 23:59:09 +0000
@@ -270,7 +270,7 @@
      * The handler must not be null.
      * This method can be called on any thread.
      */
-    void sendMessageDelayed(nsecs_t uptimeDelay, const sp<MessageHandler>& handler,
+    void sendMessageDelayed(std::chrono::nanoseconds uptimeDelay, const sp<MessageHandler>& handler,
             const Message& message);
 
     /**
@@ -281,7 +281,7 @@
      * The handler must not be null.
      * This method can be called on any thread.
      */
-    void sendMessageAtTime(nsecs_t uptime, const sp<MessageHandler>& handler,
+    void sendMessageAtTime(std::chrono::nanoseconds uptime, const sp<MessageHandler>& handler,
             const Message& message);
 
     /**
@@ -339,11 +339,11 @@
     struct MessageEnvelope {
         MessageEnvelope() : uptime(0) { }
 
-        MessageEnvelope(nsecs_t uptime, const sp<MessageHandler> handler,
+        MessageEnvelope(std::chrono::nanoseconds uptime, const sp<MessageHandler> handler,
                 const Message& message) : uptime(uptime), handler(handler), message(message) {
         }
 
-        nsecs_t uptime;
+        std::chrono::nanoseconds uptime;
         sp<MessageHandler> handler;
         Message message;
     };
@@ -366,7 +366,7 @@
     // it runs on a single thread.
     Vector<Response> mResponses;
     size_t mResponseIndex;
-    nsecs_t mNextMessageUptime; // set to LLONG_MAX when none
+    std::chrono::nanoseconds mNextMessageUptime; // set to LLONG_MAX when none
 
     int pollInner(int timeoutMillis);
     void awoken();

=== modified file '3rd_party/android-input/android/frameworks/native/libs/utils/Looper.cpp'
--- 3rd_party/android-input/android/frameworks/native/libs/utils/Looper.cpp	2012-11-21 00:36:10 +0000
+++ 3rd_party/android-input/android/frameworks/native/libs/utils/Looper.cpp	2015-02-09 23:59:09 +0000
@@ -68,7 +68,7 @@
 
 Looper::Looper(bool allowNonCallbacks) :
         mAllowNonCallbacks(allowNonCallbacks), mSendingMessage(false),
-        mResponseIndex(0), mNextMessageUptime(LLONG_MAX) {
+        mResponseIndex(0), mNextMessageUptime(std::chrono::nanoseconds(LLONG_MAX)) {
     int wakeFds[2];
     int result = pipe(wakeFds);
     LOG_ALWAYS_FATAL_IF(result != 0, "Could not create wake pipe.  errno=%d", errno);
@@ -196,8 +196,8 @@
 #endif
 
     // Adjust the timeout based on when the next message is due.
-    if (timeoutMillis != 0 && mNextMessageUptime != LLONG_MAX) {
-        nsecs_t now = systemTime(SYSTEM_TIME_MONOTONIC);
+    if (timeoutMillis != 0 && mNextMessageUptime != std::chrono::nanoseconds(LLONG_MAX)) {
+        std::chrono::nanoseconds now = systemTime(SYSTEM_TIME_MONOTONIC);
         int messageTimeoutMillis = toMillisecondTimeoutDelay(now, mNextMessageUptime);
         if (messageTimeoutMillis >= 0
                 && (timeoutMillis < 0 || messageTimeoutMillis < timeoutMillis)) {
@@ -271,9 +271,9 @@
 Done: ;
 
     // Invoke pending message callbacks.
-    mNextMessageUptime = LLONG_MAX;
+    mNextMessageUptime = std::chrono::nanoseconds(LLONG_MAX);
     while (mMessageEnvelopes.size() != 0) {
-        nsecs_t now = systemTime(SYSTEM_TIME_MONOTONIC);
+        std::chrono::nanoseconds now = systemTime(SYSTEM_TIME_MONOTONIC);
         const MessageEnvelope& messageEnvelope = mMessageEnvelopes.itemAt(0);
         if (messageEnvelope.uptime <= now) {
             // Remove the envelope from the list.
@@ -339,8 +339,8 @@
         } while (result == ALOOPER_POLL_CALLBACK);
         return result;
     } else {
-        nsecs_t endTime = systemTime(SYSTEM_TIME_MONOTONIC)
-                + milliseconds_to_nanoseconds(timeoutMillis);
+        std::chrono::nanoseconds endTime = systemTime(SYSTEM_TIME_MONOTONIC)
+            + std::chrono::duration_cast<std::chrono::nanoseconds>(std::chrono::milliseconds(timeoutMillis));
 
         for (;;) {
             int result = pollOnce(timeoutMillis, outFd, outEvents, outData);
@@ -348,7 +348,7 @@
                 return result;
             }
 
-            nsecs_t now = systemTime(SYSTEM_TIME_MONOTONIC);
+            std::chrono::nanoseconds now = systemTime(SYSTEM_TIME_MONOTONIC);
             timeoutMillis = toMillisecondTimeoutDelay(now, endTime);
             if (timeoutMillis == 0) {
                 return ALOOPER_POLL_TIMEOUT;
@@ -479,17 +479,17 @@
 }
 
 void Looper::sendMessage(const sp<MessageHandler>& handler, const Message& message) {
-    nsecs_t now = systemTime(SYSTEM_TIME_MONOTONIC);
+    std::chrono::nanoseconds now = systemTime(SYSTEM_TIME_MONOTONIC);
     sendMessageAtTime(now, handler, message);
 }
 
-void Looper::sendMessageDelayed(nsecs_t uptimeDelay, const sp<MessageHandler>& handler,
+void Looper::sendMessageDelayed(std::chrono::nanoseconds uptimeDelay, const sp<MessageHandler>& handler,
         const Message& message) {
-    nsecs_t now = systemTime(SYSTEM_TIME_MONOTONIC);
+    std::chrono::nanoseconds now = systemTime(SYSTEM_TIME_MONOTONIC);
     sendMessageAtTime(now + uptimeDelay, handler, message);
 }
 
-void Looper::sendMessageAtTime(nsecs_t uptime, const sp<MessageHandler>& handler,
+void Looper::sendMessageAtTime(std::chrono::nanoseconds uptime, const sp<MessageHandler>& handler,
         const Message& message) {
 #if DEBUG_CALLBACKS
     ALOGD("%p ~ sendMessageAtTime - uptime=%lld, handler=%p, what=%d",

=== modified file '3rd_party/android-input/android/frameworks/native/libs/utils/Timers.cpp'
--- 3rd_party/android-input/android/frameworks/native/libs/utils/Timers.cpp	2013-05-03 16:38:07 +0000
+++ 3rd_party/android-input/android/frameworks/native/libs/utils/Timers.cpp	2015-02-09 23:59:09 +0000
@@ -32,7 +32,7 @@
 #include <windows.h>
 #endif
 
-nsecs_t systemTime(int clock)
+std::chrono::nanoseconds systemTime(int clock)
 {
 #if defined(HAVE_POSIX_CLOCKS)
     static const clockid_t clocks[] = {
@@ -44,21 +44,21 @@
     struct timespec t;
     t.tv_sec = t.tv_nsec = 0;
     clock_gettime(clocks[clock], &t);
-    return nsecs_t(t.tv_sec)*1000000000LL + t.tv_nsec;
+    return std::chrono::nanoseconds(t.tv_sec)*1000000000LL + t.tv_nsec;
 #else
     // we don't support the clocks here.
     struct timeval t;
     t.tv_sec = t.tv_usec = 0;
     gettimeofday(&t, NULL);
-    return nsecs_t(t.tv_sec)*1000000000LL + nsecs_t(t.tv_usec)*1000LL;
+    return std::chrono::nanoseconds(t.tv_sec)*1000000000LL + std::chrono::nanoseconds(t.tv_usec)*1000LL;
 #endif
 }
 
-int toMillisecondTimeoutDelay(nsecs_t referenceTime, nsecs_t timeoutTime)
+int toMillisecondTimeoutDelay(std::chrono::nanoseconds referenceTime, std::chrono::nanoseconds timeoutTime)
 {
     int timeoutDelayMillis;
     if (timeoutTime > referenceTime) {
-        uint64_t timeoutDelay = uint64_t(timeoutTime - referenceTime);
+        uint64_t timeoutDelay = (timeoutTime - referenceTime).count();
         if (timeoutDelay > uint64_t((INT_MAX - 1) * 1000000LL)) {
             timeoutDelayMillis = -1;
         } else {

=== modified file 'CMakeLists.txt'
--- CMakeLists.txt	2014-12-08 04:03:47 +0000
+++ CMakeLists.txt	2015-02-09 23:59:09 +0000
@@ -27,9 +27,13 @@
 set(LIBRARY_OUTPUT_PATH ${CMAKE_BINARY_DIR}/lib)
 
 set(MIR_VERSION_MAJOR 0)
-set(MIR_VERSION_MINOR 10) # This should change at least with every MIRSERVER_ABI
+set(MIR_VERSION_MINOR 11) # This should change at least with every MIRSERVER_ABI
 set(MIR_VERSION_PATCH 0)
 
+add_definitions(-DMIR_VERSION_MAJOR=${MIR_VERSION_MAJOR})
+add_definitions(-DMIR_VERSION_MINOR=${MIR_VERSION_MINOR})
+add_definitions(-DMIR_VERSION_MICRO=${MIR_VERSION_PATCH})
+
 set(MIR_VERSION ${MIR_VERSION_MAJOR}.${MIR_VERSION_MINOR}.${MIR_VERSION_PATCH})
 
 set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} ${CMAKE_CURRENT_SOURCE_DIR}/cmake)
@@ -48,7 +52,7 @@
 include (cmake/PrePush.cmake)
 include (GNUInstallDirs)
 
-set(build_types "None;Debug;Release;RelWithDebInfo;MinSizeRel;Coverage;AddressSanitizer")
+set(build_types "None;Debug;Release;RelWithDebInfo;MinSizeRel;Coverage;AddressSanitizer;ThreadSanitizer")
 # Change informational string for CMAKE_BUILD_TYPE
 set(CMAKE_BUILD_TYPE ${CMAKE_BUILD_TYPE} CACHE STRING "${build_types}" FORCE)
 # Enable cmake-gui to display a drop down list for CMAKE_BUILD_TYPE
@@ -92,16 +96,32 @@
   set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fsanitize=address -fno-omit-frame-pointer")
   set(CMAKE_MODULE_LINKER_FLAGS "${CMAKE_MODULE_LINKER_FLAGS} -fsanitize=address")
   set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -fsanitize=address")
+elseif(cmake_build_type_lower MATCHES "threadsanitizer")
+  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fsanitize=thread -fno-omit-frame-pointer")
+  set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fsanitize=thread -fno-omit-frame-pointer")
+  if (CMAKE_COMPILER_IS_GNUCXX)
+    # Work around GCC bug. It should automatically link to tsan when
+    # -fsanitize=thread is used, but doesn't.
+    #
+    # Linking everything with tsan is harmless and simple, so do that.
+    link_libraries(tsan)
+  endif()
 else()
   # AddressSanitizer builds fail if we disallow undefined symbols
   set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -Wl,--no-undefined")
   set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -Wl,--no-undefined")
 endif()
 
+set(CMAKE_MODULE_LINKER_FLAGS_THREADSANITIZER "-fsanitize=thread")
+set(CMAKE_SHARED_LINKER_FLAGS_THREADSANITZIER "-fsanitize=thread")
+set(CMAKE_EXE_LINKER_FLAGS_THREADSANITIZER "-pie")
+
 # Define LOG_NDEBUG=1 to ensure Android ALOGV calls are not compiled in to
 # consume CPU time...
 add_definitions(-DLOG_NDEBUG=1)
 
+add_definitions(-DMIR_REQUIRE_DEPRECATED_EVENT_OPT_IN=1)
+
 enable_testing()
 
 include_directories(include/common)

=== modified file 'benchmarks/android-input/input_reader_perf.cpp'
--- benchmarks/android-input/input_reader_perf.cpp	2014-12-08 04:03:47 +0000
+++ benchmarks/android-input/input_reader_perf.cpp	2015-02-09 23:59:09 +0000
@@ -147,7 +147,7 @@
         size_t i = 0;
         while (gInputEvents[i].nsecs > 0)
         {
-            fakeEventHub->synthesize_event(gInputEvents[i].nsecs, DEVICE_ID,
+            fakeEventHub->synthesize_event(std::chrono::nanoseconds(gInputEvents[i].nsecs), DEVICE_ID,
                                            gInputEvents[i].type,
                                            gInputEvents[i].code,
                                            gInputEvents[i].value);

=== modified file 'benchmarks/frame-uniformity/touch_samples.cpp'
--- benchmarks/frame-uniformity/touch_samples.cpp	2014-10-22 14:08:51 +0000
+++ benchmarks/frame-uniformity/touch_samples.cpp	2015-02-09 23:59:09 +0000
@@ -16,6 +16,8 @@
  * Authored by: Robert Carr <[e-mail]>
  */
 
+#define MIR_INCLUDE_DEPRECATED_EVENT_HEADER
+
 #include "touch_samples.h"
 
 void TouchSamples::record_frame_time(std::chrono::high_resolution_clock::time_point time)

=== modified file 'client-ABI-sha1sums'
--- client-ABI-sha1sums	2014-12-24 01:59:05 +0000
+++ client-ABI-sha1sums	2015-02-09 23:59:09 +0000
@@ -1,27 +1,27 @@
 afd66e984f4f8c0303fd25fb6fea32fa47bbd37f  include/client/mir_toolkit/debug/surface.h
 b53736bcb22ddc09aab8275cfdd05c109fdd0f12  include/client/mir_toolkit/mir_client_library_drm.h
 532af89e0f48d8d2a7cf01621db25d3338ae3abf  include/client/mir_toolkit/mir_client_library.h
-750aa35e6a5173bcba47cb524c508d05a4df746c  include/client/mir_toolkit/mir_connection.h
+615df675ffba805fb0594e19fb006f514f2100a7  include/client/mir_toolkit/mir_connection.h
 1ef8f51a3e3f8d1559266c5af58fbfde7cfabf0a  include/client/mir_toolkit/mir_cursor_configuration.h
 d739af6e64db6b314a727b5fb00be662b98ccd57  include/client/mir_toolkit/mir_platform_message.h
 9d50df5a141ca03ee8a79f7e844ed4b8b3b7d5d3  include/client/mir_toolkit/mir_prompt_session.h
 21d07e655e85eeec8a3523e1c6f9c2252176ec01  include/client/mir_toolkit/mir_screencast.h
-82a2a3d219747a778284811ba0c01e0fdf167b30  include/client/mir_toolkit/mir_surface.h
+07c140966a72af13606993f7f8e58b79441f92e6  include/client/mir_toolkit/mir_surface.h
 b141c4d79802ad626d969249c0004744e5c2a525  include/client/mir_toolkit/mir_wait.h
 6f7b4ecc22afba923806ed2bd7d8244be90b0cfd  include/client/mir_toolkit/version.h
 3350dac884d6006753de2a955bc7a05663cd9449  include/common/mir_toolkit/client_types.h
-c7c708734715a6d1b6fb2652584adb912071a518  include/common/mir_toolkit/common.h
+b042ff8f542759fb82ad4cf1f4bab4aa2824e7f0  include/common/mir_toolkit/common.h
 fce4c1a9e0d037244f7e9e96ea2d8eaab4fc404c  include/common/mir_toolkit/cursors.h
 f4d39e9893ce6308bddd83a49b90f0051f565323  include/common/mir_toolkit/event.h
 2507f2929415aa423f9551d3c595c439fe1c6efd  include/common/mir_toolkit/events/event_deprecated.h
-cb2358a701db2b9c8d9ba1c877f29f834af259a7  include/common/mir_toolkit/events/event.h
-c591a02a8e9851db342c310cf829d018a1eddb51  include/common/mir_toolkit/events/input/input_event.h
+75f81e8250bd76c5281b8792aeadf5319eb2f169  include/common/mir_toolkit/events/event.h
+003b178a1d2418e03a13c54ca02353fa24beb1d6  include/common/mir_toolkit/events/input/input_event.h
 7748a12138474e9be218eeb8f14b372af0fcec7e  include/common/mir_toolkit/events/input/key_input_event.h
+489e8bae7c3e949ac449b09bd3bf554dae0e8986  include/common/mir_toolkit/events/input/pointer_input_event.h
 de7c23453e6d897296f32e49d9ba952a1baa0200  include/common/mir_toolkit/events/input/touch_input_event.h
 8642e85a50e2de651589da3ced70e0fc0a915f26  include/common/mir_toolkit/events/orientation_event.h
 f623dcf3c2ed134c1be20106eb54bcccc84af462  include/common/mir_toolkit/events/prompt_session_event.h
 633893b0def2b71f969872908a5b3529bc2fbf10  include/common/mir_toolkit/events/resize_event.h
 5944dc0556223cc54b45b32c8aa70b8c60ee0337  include/common/mir_toolkit/events/surface_event.h
-4975998aa1056ed0d39dcc538127453e516ad8e9  include/common/mir_toolkit/mesa/native_display.h
 101017c17714a57db57d79b7b5e7df40a3568236  include/common/mir_toolkit/mir_native_buffer.h
 4ce105a3a18241f5d33db31939ca15256f353c37  include/common/mir_toolkit/mir_version_number.h

=== modified file 'cmake/FindGtest.cmake'
--- cmake/FindGtest.cmake	2014-12-11 06:14:56 +0000
+++ cmake/FindGtest.cmake	2015-02-09 23:59:09 +0000
@@ -20,7 +20,12 @@
 set(GMOCK_BINARY_DIR ${CMAKE_BINARY_DIR}/${GMOCK_PREFIX}/libs)
 set(GTEST_BINARY_DIR ${GMOCK_BINARY_DIR}/gtest)
 
-set(GTEST_CMAKE_ARGS "-DCMAKE_CXX_FLAGS=-fPIC")
+set(GTEST_CXX_FLAGS "-fPIC")
+if (cmake_build_type_lower MATCHES "threadsanitizer")
+  set(GTEST_CXX_FLAGS "${GTEST_CXX_FLAGS} -fsanitize=thread")
+endif()
+
+set(GTEST_CMAKE_ARGS "-DCMAKE_CXX_FLAGS=${GTEST_CXX_FLAGS}")
 if (${CMAKE_CROSSCOMPILING})
   list(APPEND GTEST_CMAKE_ARGS -DCMAKE_TOOLCHAIN_FILE=${CMAKE_MODULE_PATH}/LinuxCrossCompile.cmake)
 endif()

=== modified file 'common-ABI-sha1sums'
--- common-ABI-sha1sums	2015-01-06 02:28:04 +0000
+++ common-ABI-sha1sums	2015-02-09 23:59:09 +0000
@@ -1,13 +1,17 @@
 3329ada91412ded2f127aee9a92f065e57b81cb2  include/common/mir/cached_ptr.h
+d20a846dfa0e46fb276b4c181a6a5a56e7a884da  include/common/mir/dispatch/dispatchable.h
+7bdc0e58dc228ac655a618208bf133c6a499ca13  include/common/mir/dispatch/simple_dispatch_thread.h
+4bbb26ec91310e250d3d7803575c36fd8cd8b87c  include/common/mir/events/event_builders.h
 82ff9499ef62739379616e02164dc98f9914c329  include/common/mir/fd.h
-b399dc08514751c86e23824612a52378dd9b1e23  include/common/mir/geometry/dimensions.h
-5870ce0fdde3546bfb67997c730fa51379359cae  include/common/mir/geometry/displacement.h
+fe0275d9c64e7a2d99990382d04b1fe956d7b7e4  include/common/mir/frontend/surface_id.h
+212be468fdca8134c1dff7a9cd61ecec76b26967  include/common/mir/geometry/dimensions.h
+dd2eb355262622f08280e63dbc2680068fe81d9e  include/common/mir/geometry/displacement.h
 283cb0ecf9d544300681fc2ab86bec568e2d20ff  include/common/mir/geometry/forward.h
 bfd87d9fb800c1c1b528c00185570abac569caf2  include/common/mir/geometry/length.h
 d954464ef2d20c2876db68c94512a443186da09b  include/common/mir/geometry/point.h
 dc7c62d3916eec025e8e7deaf57e06077ce38928  include/common/mir/geometry/rectangle.h
-5161774957e3ca4f5fa4e7db025d0978d2bbef06  include/common/mir/geometry/rectangles.h
-42646c2367b9821e3aa71feff6e31cf50526acaa  include/common/mir/geometry/size.h
+41446a309ee25148a9b1a66ebee205c57e014a8f  include/common/mir/geometry/rectangles.h
+20fa71bf856b1f391ad84b0afd8c197e0ca9e982  include/common/mir/geometry/size.h
 e1be9faee8b844ca2ce617f8fd82c9ee08d56bed  include/common/mir/graphics/native_buffer.h
 dcf8b8982f138bdde39a241825c610e955cd5e33  include/common/mir/input/input_platform.h
 208cd6aed5ef5f8f39b3eb86604e4133cb840485  include/common/mir/input/input_receiver_thread.h
@@ -17,18 +21,18 @@
 31b9c24e2ce7194aeea6694e81c160354033d28a  include/common/mir/optional_value.h
 9ae8473df05dd9e048a73797f01a2f34f7447554  include/common/mir/time/types.h
 3350dac884d6006753de2a955bc7a05663cd9449  include/common/mir_toolkit/client_types.h
-c7c708734715a6d1b6fb2652584adb912071a518  include/common/mir_toolkit/common.h
+b042ff8f542759fb82ad4cf1f4bab4aa2824e7f0  include/common/mir_toolkit/common.h
 fce4c1a9e0d037244f7e9e96ea2d8eaab4fc404c  include/common/mir_toolkit/cursors.h
 f4d39e9893ce6308bddd83a49b90f0051f565323  include/common/mir_toolkit/event.h
 2507f2929415aa423f9551d3c595c439fe1c6efd  include/common/mir_toolkit/events/event_deprecated.h
-cb2358a701db2b9c8d9ba1c877f29f834af259a7  include/common/mir_toolkit/events/event.h
-c591a02a8e9851db342c310cf829d018a1eddb51  include/common/mir_toolkit/events/input/input_event.h
+75f81e8250bd76c5281b8792aeadf5319eb2f169  include/common/mir_toolkit/events/event.h
+003b178a1d2418e03a13c54ca02353fa24beb1d6  include/common/mir_toolkit/events/input/input_event.h
 7748a12138474e9be218eeb8f14b372af0fcec7e  include/common/mir_toolkit/events/input/key_input_event.h
+489e8bae7c3e949ac449b09bd3bf554dae0e8986  include/common/mir_toolkit/events/input/pointer_input_event.h
 de7c23453e6d897296f32e49d9ba952a1baa0200  include/common/mir_toolkit/events/input/touch_input_event.h
 8642e85a50e2de651589da3ced70e0fc0a915f26  include/common/mir_toolkit/events/orientation_event.h
 f623dcf3c2ed134c1be20106eb54bcccc84af462  include/common/mir_toolkit/events/prompt_session_event.h
 633893b0def2b71f969872908a5b3529bc2fbf10  include/common/mir_toolkit/events/resize_event.h
 5944dc0556223cc54b45b32c8aa70b8c60ee0337  include/common/mir_toolkit/events/surface_event.h
-4975998aa1056ed0d39dcc538127453e516ad8e9  include/common/mir_toolkit/mesa/native_display.h
 101017c17714a57db57d79b7b5e7df40a3568236  include/common/mir_toolkit/mir_native_buffer.h
 4ce105a3a18241f5d33db31939ca15256f353c37  include/common/mir_toolkit/mir_version_number.h

=== modified file 'debian/changelog'
--- debian/changelog	2015-01-07 23:50:17 +0000
+++ debian/changelog	2015-02-09 23:59:09 +0000
@@ -1,3 +1,70 @@
+mir (0.11.0-0ubuntu1) UNRELEASED; urgency=medium
+
+  * New upstream release 0.11.0 (https://launchpad.net/mir/+milestone/0.11.0)
+    - Packaging changes:
+      . Due to changes in the Mir driver model the client platforms are no
+        longer versioned by soname. Thusly libmirplatform5driver-(mesa|android) is
+        replaced by mir-client-platform-(mesa-android). A new package
+        mir-client-platform-mesa-dev is introduced containing headers
+        previously in mirplatform-dev.
+    - Enhancements:
+      . Lots more major plumbing in the Android code, on the path to
+        supporting external displays.
+      . Add support for clang 3.6.
+      . Major redesign of server classes in mir::shell,scene and friends
+        (still in progress).
+      . Added client API for creating dialogs and tooltips.
+      . Added new surface states: mir_surface_state_hidden and
+        mir_surface_state_horizmaximized.
+      . Performance: Use optimally efficient fragment shading when possible.
+      . Performance: (Desktop) Composite using double buffering instead of
+        triple to reduce visible lag.
+      . mir_proving_server: Can now resize windows from any edge or corner
+        using the existing Alt+middlebuttondrag.
+      . mir_proving_server: Added some demo custom shaders (negative and
+        high contrast modes: Super+N/C).
+      . mir_proving_server: Can now close clients politely via Alt+F4.
+      . Added MirPointerInputEvent (part of the new input API, the old
+        MirMotionEvent is still supported also for now).
+    - ABI summary: Servers need rebuilding, but clients do not;
+      . Mirclient ABI unchanged at 8
+      . Mircommon ABI unchanged at 3
+      . Mirplatform ABI bumped to 6
+      . Mirserver ABI bumped to 29
+    - Bug fixes:
+      . [regression] mir_demo_server exits immediately with boost
+        bad_any_cast exception (LP: #1414630)
+      . need way to position menus and tooltips (relative positioning to
+        parent) (LP: #1324101)
+      . GLibMainLoopTest failure seen in CI (LP: #1413748)
+      . Clang builds fail in CI (LP: #1416317)
+      . segfault in mir::compositor::GLProgramFamily::Shader::init()
+        (LP: #1416482)
+      . GLRenderer: The default fragment shader is sub-optimal for alpha=1.0
+        (LP: #1350674)
+      . mesa::DisplayBuffer::post_update is triple buffered - more laggy than
+        it needs to be (LP: #1350725)
+      . Cannot connect to nested server when started from a differen vt
+        (LP: #1379266)
+      . [testfail] AsioMainLoopAlarmTest fails in CI (LP: #1392256)
+      . Compositor report inconsistently reports frame time during bypass,
+        and render time otherwise (LP: #1408906)
+      . [regression] mir_demo_client_fingerpaint doesn't paint anything any
+        more (with the mouse) (LP: #1413139)
+      . Hardware cursor is always slightly ahead of the composited image
+        (LP: #1274408)
+      . integration tests are outputting (too many) DisplayServer log
+        messages (LP: #1408231)
+      . [regression] deploy-and-test.sh doesn't work any more (unless you
+        have umockdev installed already) (LP: #1413479)
+      . Color Inverse on display. Toggle Negative Image (LP: #1400580)
+      . mir-ubuntu-vivid-armhf-ci fails consistently (LP: #1407863)
+      . Double-buffered surfaces may lag or freeze if event driven and not
+        constantly redrawing (LP: #1395581)
+      . Pointer motion and crossing events are missing (LP: #1417650)
+
+ -- Daniel van Vugt <[e-mail]>  Wed, 14 Jan 2015 16:10:37 +0800
+
 mir (0.10.0+15.04.20150107.2-0ubuntu1) vivid; urgency=medium
 
   [ Daniel van Vugt ]

=== modified file 'debian/control'
--- debian/control	2015-01-07 23:26:23 +0000
+++ debian/control	2015-02-09 23:59:09 +0000
@@ -59,21 +59,23 @@
  Contains the shared library containing the Google Protobuf definitions
  required for Mir clients and servers.
 
-Package: libmirserver28
+#TODO: Packaging infrastructure for better dependency generation,
+#      ala pkg-xorg's xviddriver:Provides and ABI detection.
+Package: libmirserver29
 Section: libs
 Architecture: i386 amd64 armhf arm64
 Multi-Arch: same
 Pre-Depends: ${misc:Pre-Depends}
 Depends: ${misc:Depends},
          ${shlibs:Depends},
-         libmir${platform-driver}-mesa | libmir${platform-driver}-android,
+         mir-platform-graphics-mesa | mir-platform-graphics-android,
 Description: Display server for Ubuntu - server library
  Mir is a display server running on linux systems, with a focus on efficiency,
  robust operation and a well-defined driver model.
  .
  Contains the shared library needed by server applications for Mir.
 
-Package: libmirplatform5
+Package: libmirplatform6
 Section: libs
 Architecture: i386 amd64 armhf arm64
 Multi-Arch: same
@@ -109,7 +111,7 @@
 Architecture: i386 amd64 armhf arm64
 Multi-Arch: same
 Pre-Depends: ${misc:Pre-Depends}
-Depends: libmirplatform5 (= ${binary:Version}), 
+Depends: libmirplatform6 (= ${binary:Version}),
          libmircommon-dev,
          libboost-program-options-dev,
          ${misc:Depends},
@@ -126,7 +128,7 @@
 Architecture: i386 amd64 armhf arm64
 Multi-Arch: same
 Pre-Depends: ${misc:Pre-Depends}
-Depends: libmirserver28 (= ${binary:Version}),
+Depends: libmirserver29 (= ${binary:Version}),
          libmirplatform-dev (= ${binary:Version}),
          libmircommon-dev (= ${binary:Version}),
          libglm-dev,
@@ -266,6 +268,34 @@
  Contains the shared libraries required for the Mir server and client.
 
 # Longer-term these drivers should move out-of-tree
+Package: mir-platform-graphics-mesa
+Section: libs
+Architecture: i386 amd64 armhf arm64
+Multi-Arch: same
+Pre-Depends: ${misc:Pre-Depends}
+Depends: ${misc:Depends},
+         ${shlibs:Depends},
+Description: Display server for Ubuntu - platform library for Mesa
+ Mir is a display server running on linux systems, with a focus on efficiency,
+ robust operation and a well-defined driver model.
+ .
+ Contains the shared libraries required for the Mir server to interact with
+ the hardware platform using the Mesa drivers.
+
+Package: mir-platform-graphics-android
+Section: libs
+Architecture: i386 amd64 armhf
+Multi-Arch: same
+Pre-Depends: ${misc:Pre-Depends}
+Depends: ${misc:Depends},
+         ${shlibs:Depends},
+Description: Display server for Ubuntu - platform library for Android
+ Mir is a display server running on linux systems, with a focus on efficiency,
+ robust operation and a well-defined driver model.
+ .
+ Contains the shared libraries required for the Mir server to interact with
+ the hardware platform using the Android drivers.
+
 Package: mir-client-platform-mesa
 Section: libs
 Architecture: i386 amd64 armhf arm64
@@ -280,6 +310,21 @@
  Contains the shared libraries required for the Mir clients to interact with
  the underlying hardware platform using the Mesa drivers.
 
+Package: mir-client-platform-mesa-dev
+Section: libdevel
+Architecture: i386 amd64 armhf arm64
+Multi-Arch: same
+Pre-Depends: ${misc:Pre-Depends}
+Depends: mir-client-platform-mesa (= ${binary:Version}),
+         libmircommon-dev,
+         ${misc:Depends},
+Description: Display server for Ubuntu - client platform library for Mesa development files
+ Mir is a display server running on linux systems, with a focus on efficiency,
+ robust operation and a well-defined driver model.
+ .
+ Contains header files required to use the platform specific capabilities of
+ the Mir Mesa backend.
+
 Package: mir-client-platform-android
 Section: libs
 Architecture: i386 amd64 armhf
@@ -294,42 +339,14 @@
  Contains the shared libraries required for the Mir clients to interact with
  the underlying hardware platform using the Android drivers.
 
-Package: libmirplatform5driver-mesa
-Section: libs
-Architecture: i386 amd64 armhf arm64
-Multi-Arch: same
-Pre-Depends: ${misc:Pre-Depends}
-Depends: ${misc:Depends},
-         ${shlibs:Depends},
-Description: Display server for Ubuntu - platform library for Mesa
- Mir is a display server running on linux systems, with a focus on efficiency,
- robust operation and a well-defined driver model.
- .
- Contains the shared libraries required for the Mir server to interact with
- the hardware platform using the Mesa drivers.
-
-Package: libmirplatform5driver-android
-Section: libs
-Architecture: i386 amd64 armhf
-Multi-Arch: same
-Pre-Depends: ${misc:Pre-Depends}
-Depends: ${misc:Depends},
-         ${shlibs:Depends},
-Description: Display server for Ubuntu - platform library for Android
- Mir is a display server running on linux systems, with a focus on efficiency,
- robust operation and a well-defined driver model.
- .
- Contains the shared libraries required for the Mir server to interact with
- the hardware platform using the Android drivers.
-
 Package: mir-graphics-drivers-desktop
 Section: libs
 Architecture: i386 amd64 armhf arm64
 Multi-Arch: same
 Pre-Depends: ${misc:Pre-Depends}
 Depends: ${misc:Depends},
-         libmir${platform-driver}-mesa,
-         mir-client-platform-mesa
+         mir-platform-graphics-mesa,
+         mir-client-platform-mesa,
 Description: Display server for Ubuntu - desktop driver metapackage
  Mir is a display server running on linux systems, with a focus on efficiency,
  robust operation and a well-defined driver model.
@@ -343,8 +360,8 @@
 Multi-Arch: same
 Pre-Depends: ${misc:Pre-Depends}
 Depends: ${misc:Depends},
-         libmir${platform-driver}-android,
-         mir-client-platform-android
+         mir-platform-graphics-android,
+         mir-client-platform-android,
 Description: Display server for Ubuntu - android driver metapackage
  Mir is a display server running on linux systems, with a focus on efficiency,
  robust operation and a well-defined driver model.

=== removed file 'debian/libmirplatform5driver-android.install'
--- debian/libmirplatform5driver-android.install	2014-12-08 04:03:47 +0000
+++ debian/libmirplatform5driver-android.install	1970-01-01 00:00:00 +0000
@@ -1,1 +0,0 @@
-usr/lib/*/mir/platform*driver/android/*

=== removed file 'debian/libmirplatform5driver-mesa.install'
--- debian/libmirplatform5driver-mesa.install	2014-12-08 04:03:47 +0000
+++ debian/libmirplatform5driver-mesa.install	1970-01-01 00:00:00 +0000
@@ -1,1 +0,0 @@
-usr/lib/*/mir/platform*driver/mesa/*

=== renamed file 'debian/libmirplatform5.install' => 'debian/libmirplatform6.install'
--- debian/libmirplatform5.install	2014-12-08 04:03:47 +0000
+++ debian/libmirplatform6.install	2015-02-09 23:59:09 +0000
@@ -1,1 +1,1 @@
-usr/lib/*/libmirplatform.so.5
+usr/lib/*/libmirplatform.so.6

=== renamed file 'debian/libmirserver28.install' => 'debian/libmirserver29.install'
--- debian/libmirserver28.install	2014-12-08 04:03:47 +0000
+++ debian/libmirserver29.install	2015-02-09 23:59:09 +0000
@@ -1,1 +1,1 @@
-usr/lib/*/libmirserver.so.28
+usr/lib/*/libmirserver.so.29

=== added file 'debian/mir-client-platform-mesa-dev.install'
--- debian/mir-client-platform-mesa-dev.install	1970-01-01 00:00:00 +0000
+++ debian/mir-client-platform-mesa-dev.install	2015-02-09 23:59:09 +0000
@@ -0,0 +1,2 @@
+usr/include/mirclient/mir_toolkit/mesa
+usr/lib/*/pkgconfig/mir-client-platform-mesa-dev.pc

=== added file 'debian/mir-platform-graphics-android.install'
--- debian/mir-platform-graphics-android.install	1970-01-01 00:00:00 +0000
+++ debian/mir-platform-graphics-android.install	2015-02-09 23:59:09 +0000
@@ -0,0 +1,1 @@
+usr/lib/*/mir/server-platform/graphics-android.so

=== added file 'debian/mir-platform-graphics-mesa.install'
--- debian/mir-platform-graphics-mesa.install	1970-01-01 00:00:00 +0000
+++ debian/mir-platform-graphics-mesa.install	2015-02-09 23:59:09 +0000
@@ -0,0 +1,1 @@
+usr/lib/*/mir/server-platform/graphics-mesa.so

=== modified file 'debian/mir-test-tools.install'
--- debian/mir-test-tools.install	2014-12-11 06:14:56 +0000
+++ debian/mir-test-tools.install	2015-02-09 23:59:09 +0000
@@ -5,5 +5,5 @@
 usr/bin/mir_performance_tests
 usr/lib/*/mir/tools/libmirclientlttng.so
 usr/lib/*/mir/tools/libmirserverlttng.so
-usr/lib/*/libmirplatformstub.so
+usr/lib/*/mir/server-platform/graphics-dummy.so
 usr/lib/*/mir/client-platform/dummy.so

=== modified file 'debian/rules'
--- debian/rules	2015-01-06 02:55:13 +0000
+++ debian/rules	2015-02-09 23:59:09 +0000
@@ -13,8 +13,6 @@
 export CC=$(DEB_HOST_GNU_TYPE)-gcc-4.9
 export CXX=$(DEB_HOST_GNU_TYPE)-g++-4.9
 
-export PLATFORM_DRIVER = platform5driver
-
 %:
 	dh $@ --parallel --fail-missing
 
@@ -57,15 +55,4 @@
 # Delete the symlink so that --fail-missing doesn't think we've missed it
 # accidentally.
 	-rm debian/tmp/usr/lib/*/libmirprotobuf.so
-	dh_install --fail-missing \
-	  -Xusr/lib/$(DEB_HOST_MULTIARCH)/libmir$(PLATFORM_DRIVER).so
-	sh debian/install_ld_so_conf.sh $(DEB_HOST_ARCH) $(DEB_HOST_MULTIARCH)
-
-override_dh_installdeb:
-	sh debian/create_postinst_prerm_scripts.sh \
-	  $(DEB_HOST_ARCH) $(DEB_HOST_MULTIARCH)
-	dh_installdeb
-
-override_dh_gencontrol:
-	dh_gencontrol -- \
-		-Vplatform-driver=$(PLATFORM_DRIVER)
+	dh_install --fail-missing

=== modified file 'deploy-and-test.sh'
--- deploy-and-test.sh	2014-03-04 05:28:46 +0000
+++ deploy-and-test.sh	2015-02-09 23:59:09 +0000
@@ -1,4 +1,5 @@
 #!/bin/sh
+# WARNING: This script is slow. See: doc/avoid_deploy-and-test.md
 
 if [ ! -d build-android-arm ] ; then
     echo "Built tree not found in $(pwd)/build-android-arm"
@@ -12,10 +13,14 @@
   dpkg -x libumockdev0_*armhf*.deb .
 )
 
-adb push build-android-arm/bin /home/phablet/mir/bin
-adb push build-android-arm/lib /home/phablet/mir/lib
-adb push build-android-arm/usr /home/phablet/mir/usr
-
-adb shell "LD_LIBRARY_PATH=/home/phablet/mir/usr/lib/arm-linux-gnueabihf/:/home/phablet/mir/lib PATH=$PATH:/home/phablet/mir/usr/bin bash -c \"cd /home/phablet/mir/usr/bin ; umockdev-run /home/phablet/mir/bin/mir_unit_tests\""
-adb shell "LD_LIBRARY_PATH=/home/phablet/mir/usr/lib/arm-linux-gnueabihf/:/home/phablet/mir/lib PATH=$PATH:/home/phablet/mir/usr/bin bash -c \"cd /home/phablet/mir/usr/bin ; umockdev-run /home/phablet/mir/bin/mir_integration_tests\""
-adb shell "LD_LIBRARY_PATH=/home/phablet/mir/usr/lib/arm-linux-gnueabihf/:/home/phablet/mir/lib PATH=$PATH:/home/phablet/mir/usr/bin bash -c \"cd /home/phablet/mir/usr/bin ; umockdev-run /home/phablet/mir/bin/mir_acceptance_tests\""
+rundir=/home/phablet/mir/testing
+adb push build-android-arm/bin $rundir/bin
+adb push build-android-arm/lib $rundir/lib
+adb push build-android-arm/usr $rundir/usr
+
+libpath=$rundir/usr/lib/arm-linux-gnueabihf/:$rundir/lib
+run_with_env="LD_LIBRARY_PATH=$libpath $rundir/usr/bin/umockdev-run $rundir/bin/"
+
+adb shell "${run_with_env}mir_unit_tests"
+adb shell "${run_with_env}mir_integration_tests"
+adb shell "${run_with_env}mir_acceptance_tests"

=== added file 'doc/avoid_deploy-and-test.md'
--- doc/avoid_deploy-and-test.md	1970-01-01 00:00:00 +0000
+++ doc/avoid_deploy-and-test.md	2015-02-09 23:59:09 +0000
@@ -0,0 +1,29 @@
+How to avoid deploy-and-test.sh
+===============================
+
+If you're running tests regularly from different branches on a remote
+Ubuntu touch device, you should avoid deploy-and-test.sh because it's very
+slow to complete. Particularly if you're making code changes and need to
+repeat the script each time. Instead, you can set up your device for rapid
+iteration like so:
+
+One-time setup
+--------------
+   adb push ~/.ssh/id_rsa.pub /home/phablet/.ssh/authorized_keys
+   adb shell
+      chown phablet ~/.ssh
+      chmod -R go-w ~/.ssh
+      mkdir ~/testrundir
+      sudo start ssh
+      sudo mount -o remount,rw /
+      sudo apt-get install umockdev
+
+Now for each branch you want to deploy and test
+-----------------------------------------------
+   device=<ip-or-hostname-of-your-device>
+   cd build-android-arm
+   rsync -avH lib bin phablet@$device:testrundir/
+   adb shell  (or ssh phablet@$device)
+      cd testrundir
+      umockdev-run bin/mir_unit-tests
+      ...

=== added file 'doc/demo_server_controls.md'
--- doc/demo_server_controls.md	1970-01-01 00:00:00 +0000
+++ doc/demo_server_controls.md	2015-02-09 23:59:09 +0000
@@ -0,0 +1,60 @@
+Demo Server {#demo_server}
+===========
+
+Mir's demo server (`mir_demo_server`) is an example of using the Mir to
+build a server. In contrast to mir_proving_server (see \ref demo_shell_controls)
+it uses only functionality supported by the public Mir API.
+
+Running Demo Server
+-------------------
+
+Remember to always run `mir_demo_server` as root on PC (not required on
+Android), as this is required for input device support (open bug
+https://bugs.launchpad.net/mir/+bug/1286252);
+
+    sudo mir_demo_server
+
+And if you're not already on the VT you wish to use, that needs to be
+specified:
+
+    sudo mir_demo_server --vt 1
+
+There are plenty more options available if you run:
+
+    mir_demo_server --help
+
+Tiling Window Manager
+---------------------
+
+One option that needs elaboration is "--window-manager tiling".
+
+This starts a (rather primitive) tiling window manager. It tracks the available
+displays and splits the available workspace into "tiles" (one per client).
+
+The following operations are supported:
+
+ - Quit (shut down the Mir server): *Ctrl-Alt-Backspace*
+ - Switch back to X: *Ctrl-Alt-F7*
+ - Switch virtual terminals (VTs): *Ctrl-Alt-(F1-F12)*
+ - Switch apps: tap or click on the corresponding tile
+ - Move window: *Alt-leftmousebutton* drag
+ - Resize window: *Alt-middle_button* drag
+ - Maximize/restore current window (to tile size): Alt-F11
+ - Maximize/restore current window (to tile height): Shift-F11
+ - Maximize/restore current window (to tile width): Ctrl-F11
+
+For those writing client code request to set the surface attribute
+`mir_surface_attrib_state` are honoured:
+ - `mir_surface_state_restored`: restores the window 
+ - `mir_surface_state_maximized`: maximizes to tile size
+ - `mir_surface_state_vertmaximized`: maximizes to tile height
+
+For a quick demo try:
+
+    sudo mir_demo_server --vt 1 --display-config sidebyside\
+     --window-manager tiling --launch bin/mir_demo_client_egltriangle\
+     --test-client bin/mir_demo_client_multiwin --test-timeout 60
+
+(Remember to unwrap the line)
+
+Want more? Log your requests at: https://bugs.launchpad.net/mir/+filebug

=== modified file 'doc/demo_shell_controls.md'
--- doc/demo_shell_controls.md	2014-12-19 02:31:34 +0000
+++ doc/demo_shell_controls.md	2015-02-09 23:59:09 +0000
@@ -34,8 +34,11 @@
  - Switch back to X: *Ctrl-Alt-F7*
  - Switch virtual terminals (VTs): *Ctrl-Alt-(F1-F12)*
  - Switch apps: *Alt-Tab* or *4-finger swipe left/right*
+ - Ask an app to close: *Alt-F4* (it may refuse or not understand)
  - Move window: *Alt-leftmousebutton* or *3-finger drag*
  - Resize window: *Alt-middlemousebutton* or *3-finger pinch/zoom*
+ - Toggle negative rendering: *Super-N*
+ - Toggle high-contrast rendering: *Super-C*
  - Sleep/wake all displays: *Alt-P* or *Android power button*
  - Rotate the focussed monitor: *Ctrl-Alt-(Left/Right/Up/Down)* or
    *Volume up/down while touching the screen*

=== modified file 'doc/mainpage.md'
--- doc/mainpage.md	2014-12-08 04:03:47 +0000
+++ doc/mainpage.md	2015-02-09 23:59:09 +0000
@@ -42,6 +42,7 @@
  - \ref using_mir_on_android
  - \ref debug_for_xmir
  - \ref demo_shell_controls
+ - \ref demo_server
 
 Getting involved
 ----------------
@@ -81,7 +82,20 @@
 Mir server is written as a library which allows the server code to be adapted
 for bespoke applications.
 
- - \subpage render_surfaces-example "render_surfaces.cpp: A simple program using the Mir library"
+ - \subpage server_example.cpp 
+   "server_example.cpp: a test executable hosting the following"
+ - \subpage server_example_input_event_filter.cpp 
+   "server_example_input_event_filter.cpp: provide a Quit command"
+ - \subpage server_example_display_configuration_policy.cpp 
+   "server_example_display_configuration_policy.cpp: configuring display layout"
+ - \subpage server_example_input_filter.cpp 
+   "server_example_input_filter.cpp: print input events to stdout"
+ - \subpage server_example_log_options.cpp 
+   "server_example_log_options.cpp: replace Mir logger with glog"
+ - \subpage server_example_window_manager.cpp 
+   "server_example_window_manager.cpp: How to wire up a window manager"
+ - \subpage server_example_window_management.cpp 
+   "server_example_window_management.cpp: simple window management examples"
 
 Working on Mir code
 -------------------

=== modified file 'examples/CMakeLists.txt'
--- examples/CMakeLists.txt	2015-01-06 08:57:38 +0000
+++ examples/CMakeLists.txt	2015-02-09 23:59:09 +0000
@@ -23,6 +23,7 @@
   server_example_fullscreen_placement_strategy.cpp
   server_example_host_lifecycle_event.cpp
   server_example_window_manager.cpp
+  server_example_window_management.cpp
 )
 
 target_link_libraries(eglapp
@@ -60,6 +61,12 @@
 target_link_libraries(mir_demo_client_cursors
   eglapp
 )
+mir_add_wrapped_executable(mir_demo_client_eglstateswitcher
+  eglstateswitcher.c
+)
+target_link_libraries(mir_demo_client_eglstateswitcher
+  eglapp
+)
 
 mir_add_wrapped_executable(mir_demo_client_basic
   basic.c
@@ -164,3 +171,20 @@
     mirserver
     mircommon
 )
+
+# FIXME: Bug not fixed yet.
+if (MIR_ENABLE_TESTS AND MIR_TEST_CLIENT_ABI)
+  # Regression tests for LP: #1415321
+
+  # To see reasons for failure:  ctest -V -R Clients-only-use-client-symbols
+  add_test(NAME Clients-only-use-client-symbols
+    WORKING_DIRECTORY ${CMAKE_BINARY_DIR}/bin
+    COMMAND /bin/sh -c "!(nm -u .mir_demo_client_* mir_demo_client* | grep -v @@MIR_CLIENT | grep 'U mir_')"
+  )
+
+  # To see reasons for failure:  ctest -V -R Clients-only-use-client-ABI
+  add_test(NAME Clients-only-use-client-ABI
+    WORKING_DIRECTORY ${CMAKE_BINARY_DIR}/bin
+    COMMAND /bin/sh -c "!(objdump -p .mir_demo_client_* mir_demo_client*  | grep NEEDED | grep libmir | grep -v libmirclient)"
+  )
+endif ()

=== modified file 'examples/eglapp.c'
--- examples/eglapp.c	2014-12-18 18:24:45 +0000
+++ examples/eglapp.c	2015-02-09 23:59:09 +0000
@@ -16,6 +16,8 @@
  * Author: Daniel van Vugt <[e-mail]>
  */
 
+#define MIR_INCLUDE_DEPRECATED_EVENT_HEADER
+
 #include "eglapp.h"
 #include "mir_toolkit/mir_client_library.h"
 #include <stdio.h>
@@ -144,6 +146,10 @@
          */
         printf("Resized to %dx%d\n", ev->resize.width, ev->resize.height);
         break;
+    case mir_event_type_close_surface:
+        printf("Received close event from server.\n");
+        running = 0;
+        break;
     default:
         break;
     }

=== added file 'examples/eglstateswitcher.c'
--- examples/eglstateswitcher.c	1970-01-01 00:00:00 +0000
+++ examples/eglstateswitcher.c	2015-02-09 23:59:09 +0000
@@ -0,0 +1,101 @@
+/*
+ * Trivial GL demo; switches surface states. Showing how simple life is with eglapp.
+ *
+ * Copyright © 2014 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Author: Alan Griffiths <[e-mail]>
+ */
+
+#include "eglapp.h"
+#include <mir_toolkit/mir_client_library.h>
+
+#include <stdio.h>
+#include <unistd.h>
+#include <GLES2/gl2.h>
+
+static void toggle_surface_state(MirSurface* const surface, MirSurfaceState* state);
+
+typedef struct Color
+{
+    GLfloat r, g, b, a;
+} Color;
+
+int main(int argc, char *argv[])
+{
+    float const opacity = mir_eglapp_background_opacity;
+    Color const orange = {0.866666667f, 0.282352941f, 0.141414141f, opacity};
+
+    unsigned int width = 120, height = 120;
+
+    if (!mir_eglapp_init(argc, argv, &width, &height))
+        return 1;
+
+    MirSurface* const surface = mir_eglapp_native_surface();
+    MirSurfaceState state = mir_surface_get_state(surface);
+
+    /* This is probably the simplest GL you can do */
+    while (mir_eglapp_running())
+    {
+        glClearColor(orange.r, orange.g, orange.b, orange.a);
+        glClear(GL_COLOR_BUFFER_BIT);
+        mir_eglapp_swap_buffers();
+        sleep(2);
+
+        toggle_surface_state(surface, &state);
+    }
+
+    mir_eglapp_shutdown();
+
+    return 0;
+}
+
+#define NEW_STATE(new_state)\
+        puts("Requesting state: " #new_state);\
+        *state = new_state
+
+void toggle_surface_state(MirSurface* const surface, MirSurfaceState* state)
+{
+    switch (*state)
+    {
+    case mir_surface_state_restored:
+        NEW_STATE(mir_surface_state_unknown);
+        break;
+
+    case mir_surface_state_minimized:
+        NEW_STATE(mir_surface_state_restored);
+        break;
+
+    case mir_surface_state_fullscreen:
+        NEW_STATE(mir_surface_state_vertmaximized);
+        break;
+
+    case mir_surface_state_maximized:
+        NEW_STATE(mir_surface_state_fullscreen);
+        break;
+
+    case mir_surface_state_vertmaximized:
+        NEW_STATE(mir_surface_state_horizmaximized);
+        break;
+
+    case mir_surface_state_horizmaximized:
+        NEW_STATE(mir_surface_state_minimized);
+        break;
+
+    default:
+        NEW_STATE(mir_surface_state_maximized);
+        break;
+    }
+    mir_surface_set_state(surface, *state);
+}

=== modified file 'examples/fingerpaint.c'
--- examples/fingerpaint.c	2014-12-17 00:08:22 +0000
+++ examples/fingerpaint.c	2015-02-09 23:59:09 +0000
@@ -212,18 +212,38 @@
         static float max_pressure = 1.0f;
 
         MirInputEvent const* input_event = mir_event_get_input_event(event);
-        if (mir_input_event_get_type(input_event) != mir_input_event_type_touch)
-            return;
-        MirTouchInputEvent const* tev = mir_input_event_get_touch_input_event(input_event);
-        unsigned touch_count = mir_touch_input_event_get_touch_count(tev);
-        
-        if (touch_count == 1 && mir_touch_input_event_get_touch_action(tev, 0) == mir_touch_input_event_action_up)
+        MirTouchInputEvent const* tev = NULL;
+        MirPointerInputEvent const* pev = NULL;
+        unsigned touch_count = 0;
+        bool ended = false;
+        MirInputEventType type = mir_input_event_get_type(input_event);
+
+        switch (type)
+        {
+        case mir_input_event_type_touch:
+            tev = mir_input_event_get_touch_input_event(input_event);
+            touch_count = mir_touch_input_event_get_touch_count(tev);
+            ended = touch_count == 1 &&
+                    (mir_touch_input_event_get_touch_action(tev, 0) ==
+                     mir_touch_input_event_action_up);
+            break;
+        case mir_input_event_type_pointer:
+            pev = mir_input_event_get_pointer_input_event(input_event);
+            ended = mir_pointer_input_event_get_action(pev) ==
+                mir_pointer_input_event_action_button_up;
+            touch_count = mir_pointer_input_event_get_button_state(pev,
+                               mir_pointer_input_button_primary) ? 1 : 0;
+        default:
+            break;
+        }
+
+        if (ended)
         {
             base_color = (base_color + max_fingers) %
                          (sizeof(color)/sizeof(color[0]));
             max_fingers = 0;
         }
-        else
+        else if (touch_count)
         {
             size_t p;
 
@@ -232,13 +252,33 @@
 
             for (p = 0; p < touch_count; p++)
             {
-                int x = mir_touch_input_event_get_touch_axis_value(tev, p, mir_touch_input_axis_x);
-                int y = mir_touch_input_event_get_touch_axis_value(tev, p, mir_touch_input_axis_y);
-                float size = mir_touch_input_event_get_touch_axis_value(tev, p, mir_touch_input_axis_size);
-                float pressure = mir_touch_input_event_get_touch_axis_value(tev, p, mir_touch_input_axis_pressure);
-
-                int radius = size * 50.0f
-                             + 1.0f;
+                int x = 0;
+                int y = 0;
+                int radius = 1;
+                float pressure = 1.0f;
+
+                if (tev != NULL)
+                {
+                    x = mir_touch_input_event_get_touch_axis_value(tev, p,
+                        mir_touch_input_axis_x);
+                    y = mir_touch_input_event_get_touch_axis_value(tev, p,
+                        mir_touch_input_axis_y);
+                    float size = mir_touch_input_event_get_touch_axis_value(
+                        tev, p, mir_touch_input_axis_size);
+                    pressure = mir_touch_input_event_get_touch_axis_value(tev,
+                        p, mir_touch_input_axis_pressure);
+                    radius = size * 50.0f + 1.0f;
+                }
+                else if (pev != NULL)
+                {
+                    x = mir_pointer_input_event_get_axis_value(pev,
+                        mir_pointer_input_axis_x);
+                    y = mir_pointer_input_event_get_axis_value(pev,
+                        mir_pointer_input_axis_y);
+                    pressure = 0.5f;
+                    radius = 5;
+                }
+
                 size_t c = (base_color + p) %
                            (sizeof(color)/sizeof(color[0]));
                 Color tone = color[c];
@@ -254,6 +294,19 @@
             redraw(surface, canvas);
         }
     }
+    else if (event_type == mir_event_type_close_surface)
+    {
+        static int closing = 0;
+
+        ++closing;
+        if (closing == 1)
+            printf("Sure you don't want to save your work?\n");
+        else if (closing > 1)
+        {
+            printf("Oh I forgot you can't save your work. Quitting now...\n");
+            running = 0;
+        }
+    }
     else if (event_type == mir_event_type_resize)
     {
         /* FIXME: https://bugs.launchpad.net/mir/+bug/1194384

=== modified file 'examples/render_overlays.cpp'
--- examples/render_overlays.cpp	2014-12-19 02:31:34 +0000
+++ examples/render_overlays.cpp	2015-02-09 23:59:09 +0000
@@ -162,16 +162,6 @@
         return false;
     }
 
-    bool visible() const override
-    {
-        return true;
-    }
-
-    int buffers_ready_for_compositor() const override
-    {
-        return 1;
-    }
-
 private:
     std::shared_ptr<DemoOverlayClient> const client;
     geom::Rectangle const position;

=== modified file 'examples/server_example.cpp'
--- examples/server_example.cpp	2015-01-05 14:20:50 +0000
+++ examples/server_example.cpp	2015-02-09 23:59:09 +0000
@@ -83,10 +83,6 @@
 {
     mir::Server server;
 
-    // Create some input filters (we need to keep them or they deactivate)
-    auto const quit_filter = me::make_quit_filter_for(server);
-    auto const printing_filter = me::make_printing_input_filter_for(server);
-
     // Add example options for display layout, logging, launching clients and timeout
     me::add_display_configuration_options_to(server);
     me::add_log_host_lifecycle_option_to(server);
@@ -98,6 +94,10 @@
     std::atomic<bool> test_failed{false};
     me::add_test_client_option_to(server, test_failed);
 
+    // Create some input filters (we need to keep them or they deactivate)
+    auto const quit_filter = me::make_quit_filter_for(server);
+    auto const printing_filter = me::make_printing_input_filter_for(server);
+
     // Provide the command line and run the server
     server.set_command_line(argc, argv);
     server.apply_settings();

=== added file 'examples/server_example_window_management.cpp'
--- examples/server_example_window_management.cpp	1970-01-01 00:00:00 +0000
+++ examples/server_example_window_management.cpp	2015-02-09 23:59:09 +0000
@@ -0,0 +1,703 @@
+/*
+ * Copyright © 2014 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 3,
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored By: Alan Griffiths <[e-mail]>
+ */
+
+#define MIR_INCLUDE_DEPRECATED_EVENT_HEADER 
+
+#include "server_example_window_management.h"
+#include "server_example_fullscreen_placement_strategy.h"
+
+#include "mir/abnormal_exit.h"
+#include "mir/server.h"
+#include "mir/geometry/rectangles.h"
+#include "mir/geometry/displacement.h"
+#include "mir/input/composite_event_filter.h"
+#include "mir/options/option.h"
+#include "mir/scene/session_listener.h"
+#include "mir/shell/focus_controller.h"
+
+#include <linux/input.h>
+
+#include <map>
+#include <vector>
+#include <mutex>
+
+namespace mc = mir::compositor;
+namespace me = mir::examples;
+namespace mg = mir::graphics;
+namespace mi = mir::input;
+namespace ms = mir::scene;
+namespace msh = mir::shell;
+using namespace mir::geometry;
+
+///\example server_example_window_management.cpp
+/// Demonstrate simple window management strategies
+
+char const* const me::wm_option = "window-manager";
+char const* const me::wm_description = "window management strategy [{tiling|fullscreen}]";
+
+namespace
+{
+char const* const wm_tiling = "tiling";
+char const* const wm_fullscreen = "fullscreen";
+
+// Very simple - make every surface fullscreen
+class FullscreenWindowManager : public me::WindowManager, me::FullscreenPlacementStrategy
+{
+public:
+    using me::FullscreenPlacementStrategy::FullscreenPlacementStrategy;
+
+private:
+    void add_surface(std::shared_ptr<ms::Surface> const&, ms::Session*) override {}
+
+    void remove_surface(std::weak_ptr<ms::Surface> const&, ms::Session*) override {}
+
+    void add_session(std::shared_ptr<ms::Session> const&) override {}
+
+    void remove_session(std::shared_ptr<ms::Session> const&) override {}
+
+    void add_display(Rectangle const&) override {}
+
+    void remove_display(Rectangle const&) override {}
+
+    void click(Point) override {}
+
+    void drag(Point) override {}
+
+    void resize(Point) override {}
+
+    void toggle(MirSurfaceState) override {}
+
+    int select_attribute_value(ms::Surface const&, MirSurfaceAttrib, int requested_value) override
+        { return requested_value; }
+
+    void attribute_set(ms::Surface const&, MirSurfaceAttrib, int) override {}
+};
+
+// simple tiling algorithm:
+//  o Switch apps: tap or click on the corresponding tile
+//  o Move window: Alt-leftmousebutton drag
+//  o Resize window: Alt-middle_button drag
+//  o Maximize/restore current window (to tile size): Alt-F11
+//  o Maximize/restore current window (to tile height): Shift-F11
+//  o Maximize/restore current window (to tile width): Ctrl-F11
+//  o client requests to maximize, vertically maximize & restore
+class TilingWindowManager : public me::WindowManager
+{
+public:
+    // We can't take the msh::FocusController directly as we create a WindowManager
+    // in the_session_listener() and that is called when creating the focus controller
+    using FocusControllerFactory = std::function<std::shared_ptr<msh::FocusController>()>;
+
+    explicit TilingWindowManager(FocusControllerFactory const& focus_controller) :
+        focus_controller{focus_controller}
+    {
+    }
+
+    auto place(ms::Session const& session, ms::SurfaceCreationParameters const& request_parameters)
+    -> ms::SurfaceCreationParameters override
+    {
+        auto parameters = request_parameters;
+
+        std::lock_guard<decltype(mutex)> lock(mutex);
+        auto const ptile = session_info.find(&session);
+        if (ptile != end(session_info))
+        {
+            Rectangle const& tile = ptile->second.tile;
+            parameters.top_left = parameters.top_left + (tile.top_left - Point{0, 0});
+
+            clip_to_tile(parameters, tile);
+        }
+
+        return parameters;
+    }
+
+    void add_surface(
+        std::shared_ptr<ms::Surface> const& surface,
+        ms::Session* session) override
+    {
+        std::lock_guard<decltype(mutex)> lock(mutex);
+        session_info[session].surfaces.push_back(surface);
+        surface_info[surface].session = session_info[session].session;
+        surface_info[surface].state = mir_surface_state_restored;
+    }
+
+    void remove_surface(
+        std::weak_ptr<ms::Surface> const& surface,
+        ms::Session* session) override
+    {
+        std::lock_guard<decltype(mutex)> lock(mutex);
+        auto& surfaces = session_info[session].surfaces;
+
+        for (auto i = begin(surfaces); i != end(surfaces); ++i)
+        {
+            if (surface.lock() == i->lock())
+            {
+                surfaces.erase(i);
+                break;
+            }
+        }
+
+        surface_info.erase(surface);
+    }
+
+    void add_session(std::shared_ptr<ms::Session> const& session) override
+    {
+        std::lock_guard<decltype(mutex)> lock(mutex);
+        session_info[session.get()] = session;
+        update_tiles();
+    }
+
+    void remove_session(std::shared_ptr<ms::Session> const& session) override
+    {
+        std::lock_guard<decltype(mutex)> lock(mutex);
+        session_info.erase(session.get());
+        update_tiles();
+    }
+
+    void add_display(Rectangle const& area) override
+    {
+        std::lock_guard<decltype(mutex)> lock(mutex);
+        displays.add(area);
+        update_tiles();
+    }
+
+    void remove_display(Rectangle const& area) override
+    {
+        std::lock_guard<decltype(mutex)> lock(mutex);
+        displays.remove(area);
+        update_tiles();
+    }
+
+    void click(Point cursor) override
+    {
+        std::lock_guard<decltype(mutex)> lock(mutex);
+
+        if (auto const session = session_under(cursor))
+            focus_controller()->set_focus_to(session);
+
+        old_cursor = cursor;
+    }
+
+    void drag(Point cursor) override
+    {
+        std::lock_guard<decltype(mutex)> lock(mutex);
+
+        if (auto const session = session_under(cursor))
+        {
+            if (session == session_under(old_cursor))
+            {
+                auto const& info = session_info[session.get()];
+
+                if (drag(old_surface.lock(), cursor, old_cursor, info.tile))
+                {
+                    // Still dragging the same old_surface
+                }
+                else if (drag(session->default_surface(), cursor, old_cursor, info.tile))
+                {
+                    old_surface = session->default_surface();
+                }
+                else
+                {
+                    for (auto const& ps : info.surfaces)
+                    {
+                        auto const new_surface = ps.lock();
+
+                        if (drag(new_surface, cursor, old_cursor, info.tile))
+                        {
+                            old_surface = new_surface;
+                            break;
+                        }
+                    }
+                }