[mojo-edk] Add MojoWatch and MojoCancelWatch APIs

mojo/edk/system/dispatcher.cc

 // 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.
 
 #include "mojo/edk/system/dispatcher.h"
 
 #include "base/logging.h"
 #include "mojo/edk/system/configuration.h"
 #include "mojo/edk/system/data_pipe_consumer_dispatcher.h"
 #include "mojo/edk/system/data_pipe_producer_dispatcher.h"
 #include "mojo/edk/system/message_pipe_dispatcher.h"
 #include "mojo/edk/system/platform_handle_dispatcher.h"
 #include "mojo/edk/system/shared_buffer_dispatcher.h"
 
 namespace mojo {
 namespace edk {
 
+Dispatcher::RequestContext::RequestContext() {}
+
+Dispatcher::RequestContext::~RequestContext() {
+  for (const auto& finalizer : finalizers_.container())
+    finalizer.Run();
+}
+
+void Dispatcher::RequestContext::AddFinalizer(const base::Closure& callback) {
+  finalizers_->push_back(callback);
+}
+
 Dispatcher::DispatcherInTransit::DispatcherInTransit() {}
 
 Dispatcher::DispatcherInTransit::~DispatcherInTransit() {}
 
+MojoResult Dispatcher::Watch(MojoHandleSignals signals,
+                             const WatchCallback& callback,
+                             uintptr_t context,
+                             RequestContext* request_context) {
+  return MOJO_RESULT_INVALID_ARGUMENT;
+}
+
+MojoResult Dispatcher::CancelWatch(uintptr_t context) {
+  return MOJO_RESULT_INVALID_ARGUMENT;
+}
+
 MojoResult Dispatcher::WriteMessage(const void* bytes,
                                     uint32_t num_bytes,
                                     const DispatcherInTransit* dispatchers,
                                     uint32_t num_dispatchers,
-                                    MojoWriteMessageFlags flags) {
+                                    MojoWriteMessageFlags flags,
+                                    RequestContext* request_context) {
   return MOJO_RESULT_INVALID_ARGUMENT;
 }
 
 MojoResult Dispatcher::ReadMessage(void* bytes,
                                    uint32_t* num_bytes,
                                    MojoHandle* handles,
                                    uint32_t* num_handles,
-                                   MojoReadMessageFlags flags) {
+                                   MojoReadMessageFlags flags,
+                                   RequestContext* request_context) {
   return MOJO_RESULT_INVALID_ARGUMENT;
 }
 
 MojoResult Dispatcher::DuplicateBufferHandle(
     const MojoDuplicateBufferHandleOptions* options,
     scoped_refptr<Dispatcher>* new_dispatcher) {
   return MOJO_RESULT_INVALID_ARGUMENT;
 }
 
 MojoResult Dispatcher::MapBuffer(
@@ skipping 79 matching lines @@
   *num_platform_handles = 0;
 }
 
 bool Dispatcher::EndSerialize(void* destination,
                               ports::PortName* ports,
                               PlatformHandle* handles) {
   LOG(ERROR) << "Attempting to serialize a non-transferrable dispatcher.";
   return true;
 }
 
-bool Dispatcher::BeginTransit() { return true; }
+bool Dispatcher::BeginTransit(RequestContext* request_context) { return true; }
 
-void Dispatcher::CompleteTransitAndClose() {}
+void Dispatcher::CompleteTransitAndClose(RequestContext* request_context) {}
 
-void Dispatcher::CancelTransit() {}
+void Dispatcher::CancelTransit(RequestContext* request_context) {}
 
 // static
 scoped_refptr<Dispatcher> 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 23 matching lines @@
       return nullptr;
   }
 }
 
 Dispatcher::Dispatcher() {}
 
 Dispatcher::~Dispatcher() {}
 
 }  // namespace edk
 }  // namespace mojo