[mojo-edk] Add MojoWatch and MojoCancelWatch APIs

mojo/edk/system/dispatcher.h

 // Copyright 2013 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.
 
 #ifndef MOJO_EDK_SYSTEM_DISPATCHER_H_
 #define MOJO_EDK_SYSTEM_DISPATCHER_H_
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <ostream>
 #include <vector>
 
+#include "base/callback.h"
+#include "base/containers/stack_container.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/synchronization/lock.h"
 #include "mojo/edk/embedder/platform_handle.h"
 #include "mojo/edk/embedder/platform_shared_buffer.h"
 #include "mojo/edk/system/handle_signals_state.h"
 #include "mojo/edk/system/ports/name.h"
 #include "mojo/edk/system/system_impl_export.h"
 #include "mojo/public/c/system/buffer.h"
 #include "mojo/public/c/system/data_pipe.h"
 #include "mojo/public/c/system/message_pipe.h"
 #include "mojo/public/c/system/types.h"
 
 namespace mojo {
 namespace edk {
 
 class Awakable;
 class Dispatcher;
 
 using DispatcherVector = std::vector<scoped_refptr<Dispatcher>>;
 
 // A |Dispatcher| implements Mojo EDK calls that are associated with a
 // particular MojoHandle, with the exception of MojoWait and MojoWaitMany (
 // which are implemented directly in Core.).
 class MOJO_SYSTEM_IMPL_EXPORT Dispatcher
     : public base::RefCountedThreadSafe<Dispatcher> {
  public:
+  using WatchCallback =
+      base::Callback<void(MojoResult, MojoHandleSignalsState)>;
+
+  // Context associated with a single EDK request.
+  class RequestContext {
+   public:
+    static const size_t kFinalizersStackBufferSize = 4;

[Anand Mistry (off Chromium), 2016/02/29 12:03:35]

Shouldn't these be private?

[Ken Rockot(use gerrit already), 2016/02/29 20:59:06]

Done

+    using FinalizerList =
+        base::StackVector<base::Closure, kFinalizersStackBufferSize>;
+
+    RequestContext();
+    ~RequestContext();
+
+    // Adds |callback| to the context's list of finalizers. These are called
+    // when the context is destroyed, at a time when no EDK locks are held.
+    void AddFinalizer(const base::Closure& callback);

[Anand Mistry (off Chromium), 2016/02/29 12:03:35]

Hmm... Since you're already making an effort to avoid allocs, and these closure
are always made with the same signature, maybe this should just take the watch
function and its arguments (and rename accordingly). Maybe it's premature, but
the cost of malloc/free and the CAS (increment) operation in refcounting (inside
base::Callback) are significant and paid on every inbound message.

[Ken Rockot(use gerrit already), 2016/02/29 20:59:06]

I agree, base::Callback is overkill. To support reliable cancellation I've made
Watcher a ref-counted thing, which I think is OK since it's not exposed in many
places. Anyway, we now pass a ref to the Watcher and the arguments to invoke its
callback with.

+
+   private:
+    FinalizerList finalizers_;
+
+    DISALLOW_COPY_AND_ASSIGN(RequestContext);
+  };
+
   struct DispatcherInTransit {
     DispatcherInTransit();
     ~DispatcherInTransit();
 
     scoped_refptr<Dispatcher> dispatcher;
     MojoHandle local_handle;
   };
 
   enum class Type {
     UNKNOWN = 0,
     MESSAGE_PIPE,
     DATA_PIPE_PRODUCER,
     DATA_PIPE_CONSUMER,
     SHARED_BUFFER,
     WAIT_SET,
 
     // "Private" types (not exposed via the public interface):
     PLATFORM_HANDLE = -1,
   };
 
   // All Dispatchers must minimally implement these methods.
 
   virtual Type GetType() const = 0;
-  virtual MojoResult Close() = 0;
+  virtual MojoResult Close(RequestContext* request_context) = 0;
+
+  ///////////// Watch API ////////////////////
+
+  // NOTE: The Dispatcher implementation MUST NOT hold any locks at any point
+  // during which it chooses to run |callback|.
+  virtual MojoResult Watch(MojoHandleSignals signals,
+                           const WatchCallback& callback,
+                           uintptr_t context,
+                           RequestContext* request_context);
+
+  virtual MojoResult CancelWatch(uintptr_t context);
 
   ///////////// Message pipe API /////////////
 
   virtual MojoResult WriteMessage(const void* bytes,
                                   uint32_t num_bytes,
                                   const DispatcherInTransit* dispatchers,
                                   uint32_t num_dispatchers,
-                                  MojoWriteMessageFlags flags);
+                                  MojoWriteMessageFlags flags,
+                                  RequestContext* request_context);
 
   virtual MojoResult ReadMessage(void* bytes,
                                  uint32_t* num_bytes,
                                  MojoHandle* handles,
                                  uint32_t* num_handles,
-                                 MojoReadMessageFlags flags);
+                                 MojoReadMessageFlags flags,
+                                 RequestContext* request_context);
 
   ///////////// Shared buffer API /////////////
 
   // |options| may be null. |new_dispatcher| must not be null, but
   // |*new_dispatcher| should be null (and will contain the dispatcher for the
   // new handle on success).
   virtual MojoResult DuplicateBufferHandle(
       const MojoDuplicateBufferHandleOptions* options,
       scoped_refptr<Dispatcher>* new_dispatcher);
 
@@ skipping 110 matching lines @@
   // CompleteTransitAndClose() is called. In other words, if CancelTransit() is
   // called, the implementation should retain its PlatformHandles in working
   // condition.
   virtual bool EndSerialize(void* destination,
                             ports::PortName* ports,
                             PlatformHandle* handles);
 
   // Does whatever is necessary to begin transit of the dispatcher.  This
   // should return |true| if transit is OK, or false if the underlying resource
   // is deemed busy by the implementation.
-  virtual bool BeginTransit();
+  virtual bool BeginTransit(RequestContext* request_context);
 
   // Does whatever is necessary to complete transit of the dispatcher, including
   // closure. This is only called upon successfully transmitting an outgoing
   // message containing this serialized dispatcher.
-  virtual void CompleteTransitAndClose();
+  virtual void CompleteTransitAndClose(RequestContext* request_context);
 
   // Does whatever is necessary to cancel transit of the dispatcher. The
   // dispatcher should remain in a working state and resume normal operation.
-  virtual void CancelTransit();
+  virtual void CancelTransit(RequestContext* request_context);
 
   // Deserializes a specific dispatcher type from an incoming message.
   static scoped_refptr<Dispatcher> Deserialize(
       Type type,
       const void* bytes,
       size_t num_bytes,
       const ports::PortName* ports,
       size_t num_ports,
       PlatformHandle* platform_handles,
       size_t num_platform_handles);
@@ skipping 10 matching lines @@
 // So logging macros and |DCHECK_EQ()|, etc. work.
 MOJO_SYSTEM_IMPL_EXPORT inline std::ostream& operator<<(std::ostream& out,
                                                         Dispatcher::Type type) {
   return out << static_cast<int>(type);
 }
 
 }  // namespace edk
 }  // namespace mojo
 
 #endif  // MOJO_EDK_SYSTEM_DISPATCHER_H_