Update mojo sdk to rev f6c8ec07c01deebc13178d516225fd12695c3dc2

mojo/public/dart/src/handle_watcher.dart

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 part of core;
 
 class _MojoHandleWatcherNatives {
   static int sendControlData(
       int controlHandle, int mojoHandle, SendPort port, int data)
       native "MojoHandleWatcher_SendControlData";
@@ skipping 27 matching lines @@
 //     be notified about a handle ready for writing is made the opposite.
 //
 // close(handle) - Notifies the HandleWatcherIsolate that a handle it is
 //     watching should be removed from its set and closed.
 class MojoHandleWatcher {
   // Control commands.
   static const int ADD = 0;
   static const int REMOVE = 1;
   static const int TOGGLE_WRITE = 2;
   static const int CLOSE = 3;
-  static const int SHUTDOWN = 4;
+  static const int TIMER = 4;
+  static const int SHUTDOWN = 5;
 
   static int _encodeCommand(int cmd, [int signals = 0]) =>
       (cmd << 2) | (signals & MojoHandleSignals.READWRITE);
   static int _decodeCommand(int cmd) => cmd >> 2;
 
   // The Mojo handle over which control messages are sent.
   int _controlHandle;
 
   // Whether the handle watcher should shut down.
   bool _shutdown;
 
   // The list of handles being watched.
   List<int> _handles;
   int _handleCount;
 
   // A port for each handle on which to send events back to the isolate that
   // owns the handle.
   List<SendPort> _ports;
 
   // The signals that we care about for each handle.
   List<int> _signals;
 
   // A mapping from Mojo handles to their indices in _handles.
   Map<int, int> _handleIndices;
 
   // Since we are not storing wrapped handles, a dummy handle for when we need
   // a RawMojoHandle.
   RawMojoHandle _tempHandle;
 
+  // Priority queue of timers registered with the watcher.
+  TimerQueue _timerQueue;
+
   MojoHandleWatcher(this._controlHandle) :
       _shutdown = false,
       _handles = new List<int>(),
       _ports = new List<SendPort>(),
       _signals = new List<int>(),
       _handleIndices = new Map<int, int>(),
       _handleCount = 1,
-      _tempHandle = new RawMojoHandle(RawMojoHandle.INVALID) {
+      _tempHandle = new RawMojoHandle(RawMojoHandle.INVALID),
+      _timerQueue = new TimerQueue() {
     // Setup control handle.
     _handles.add(_controlHandle);
     _ports.add(null);  // There is no port for the control handle.
     _signals.add(MojoHandleSignals.READABLE);
     _handleIndices[_controlHandle] = 0;
   }
 
-  static void _handleWatcherIsolate(MojoHandleWatcher watcher) {
+  static void _handleWatcherIsolate(int consumerHandle) {
+    MojoHandleWatcher watcher = new MojoHandleWatcher(consumerHandle);
     while (!watcher._shutdown) {
+      int deadline = watcher._processTimerDeadlines();
       int res = RawMojoHandle.waitMany(watcher._handles,
                                        watcher._signals,
-                                       RawMojoHandle.DEADLINE_INDEFINITE);
+                                       deadline);
       if (res == 0) {
         watcher._handleControlMessage();
       } else if (res > 0) {
         int handle = watcher._handles[res];
         // Route event.
         watcher._routeEvent(res);
         // Remove the handle from the list.
         watcher._removeHandle(handle);
-      } else {
+      } else if (res != MojoResult.kDeadlineExceeded) {
         // Some handle was closed, but not by us.
         // We have to go through the list and find it.
         watcher._pruneClosedHandles();
       }
     }
   }
 
   void _routeEvent(int idx) {
     int client_handle = _handles[idx];
     int signals = _signals[idx];
     SendPort port = _ports[idx];
 
     _tempHandle.h = client_handle;
     bool readyWrite =
         MojoHandleSignals.isWritable(signals) && _tempHandle.readyWrite();
     bool readyRead =
         MojoHandleSignals.isReadable(signals) && _tempHandle.readyRead();
     if (readyRead && readyWrite) {
       port.send(MojoHandleSignals.READWRITE);
     } else if (readyWrite) {
       port.send(MojoHandleSignals.WRITABLE);
     } else if (readyRead) {
       port.send(MojoHandleSignals.READABLE);
     }
     _tempHandle.h = RawMojoHandle.INVALID;
   }
 
   void _handleControlMessage() {
     List result = _MojoHandleWatcherNatives.recvControlData(_controlHandle);
-    // result[0] = mojo handle if any
-    // result[1] = SendPort if any
+    // result[0] = mojo handle if any, or a timer deadline in milliseconds.
+    // result[1] = SendPort if any.
     // result[2] = command << 2 | WRITABLE | READABLE
 
     int signals = result[2] & MojoHandleSignals.READWRITE;
     int command = _decodeCommand(result[2]);
     switch (command) {
       case ADD:
         _addHandle(result[0], result[1], signals);
         break;
       case REMOVE:
         _removeHandle(result[0]);
         break;
       case TOGGLE_WRITE:
         _toggleWrite(result[0]);
         break;
       case CLOSE:
         _close(result[0]);
         break;
+      case TIMER:
+        _timer(result[1], result[0]);
+        break;
       case SHUTDOWN:
         _shutdownHandleWatcher();
         break;
       default:
         throw new Exception("Invalid Command: $command");
         break;
     }
   }
 
   void _addHandle(int mojoHandle, SendPort port, int signals) {
@@ skipping 45 matching lines @@
     _tempHandle.close();
     _tempHandle.h = RawMojoHandle.INVALID;
     if (pruning) {
       // If this handle is being pruned, notify the application isolate
       // by sending MojoHandleSignals.NONE.
       _ports[idx].send(MojoHandleSignals.NONE);
     }
     _removeHandle(mojoHandle);
   }
 
+  // Returns the next timer deadline in units of microseconds from 'now'.
+  int _processTimerDeadlines() {
+    int now = (new DateTime.now()).millisecondsSinceEpoch;
+    while (_timerQueue.hasTimer && (now >= _timerQueue.currentTimeout)) {
+      _timerQueue.currentPort.send(null);
+      _timerQueue.removeCurrent();
+      now = (new DateTime.now()).millisecondsSinceEpoch;
+    }
+    return _timerQueue.hasTimer ? (_timerQueue.currentTimeout - now) * 1000
+                                : RawMojoHandle.DEADLINE_INDEFINITE;
+  }
+
+  void _timer(SendPort port, int deadline) {
+    _timerQueue.updateTimer(port, deadline);
+  }
+
   void _toggleWrite(int mojoHandle) {
     int idx = _handleIndices[mojoHandle];
     if (idx == null) {
       throw new Exception(
           "Toggle write on a non-existent handle: $mojoHandle.");
     }
     if (idx == 0) {
       throw new Exception("The control handle (idx = 0) cannot be toggled.");
     }
     _signals[idx] = MojoHandleSignals.toggleWrite(_signals[idx]);
@@ skipping 37 matching lines @@
         controlHandle, rawHandle, port, data);
     return new MojoResult(result);
   }
 
   static Future<Isolate> Start() {
     // Make a control message pipe,
     MojoMessagePipe pipe = new MojoMessagePipe();
     int consumerHandle = pipe.endpoints[0].handle.h;
     int producerHandle = pipe.endpoints[1].handle.h;
 
-    // Make a MojoHandleWatcher with one end.
-    MojoHandleWatcher watcher = new MojoHandleWatcher(consumerHandle);
-
     // Call setControlHandle with the other end.
     _MojoHandleWatcherNatives.setControlHandle(producerHandle);
 
     // Spawn the handle watcher isolate with the MojoHandleWatcher,
-    return Isolate.spawn(_handleWatcherIsolate, watcher);
+    return Isolate.spawn(_handleWatcherIsolate, consumerHandle);
   }
 
   static void Stop() {
     // Send the shutdown command.
     _sendControlData(null, null, _encodeCommand(SHUTDOWN));
 
     // Close the control handle.
     int controlHandle = _MojoHandleWatcherNatives.getControlHandle();
     var handle = new RawMojoHandle(controlHandle);
     handle.close();
+
+    // Invalidate the control handle.
+    _MojoHandleWatcherNatives.setControlHandle(RawMojoHandle.INVALID);
   }
 
   static MojoResult close(RawMojoHandle mojoHandle) {
     return _sendControlData(mojoHandle, null, _encodeCommand(CLOSE));
   }
 
   static MojoResult toggleWrite(RawMojoHandle mojoHandle) {
     return _sendControlData(mojoHandle, null, _encodeCommand(TOGGLE_WRITE));
   }
 
   static MojoResult add(RawMojoHandle mojoHandle, SendPort port, int signals) {
     return _sendControlData(mojoHandle, port, _encodeCommand(ADD, signals));
   }
 
   static MojoResult remove(RawMojoHandle mojoHandle) {
     return _sendControlData(mojoHandle, null, _encodeCommand(REMOVE));
   }
+
+  static MojoResult timer(SendPort port, int deadline) {
+    // The deadline will be unwrapped before sending to the handle watcher.
+    return _sendControlData(
+        new RawMojoHandle(deadline), port, _encodeCommand(TIMER));
+  }
 }