[mojo-edk] Add MojoWatch and MojoCancelWatch APIs

mojo/edk/system/data_pipe_producer_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/data_pipe_producer_dispatcher.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/memory/ref_counted.h"
 #include "base/message_loop/message_loop.h"
 #include "mojo/edk/embedder/embedder_internal.h"
 #include "mojo/edk/embedder/platform_shared_buffer.h"
 #include "mojo/edk/system/configuration.h"
 #include "mojo/edk/system/core.h"
 #include "mojo/edk/system/data_pipe_control_message.h"
 #include "mojo/edk/system/node_controller.h"
 #include "mojo/edk/system/ports_message.h"
+#include "mojo/edk/system/request_context.h"
+#include "mojo/public/c/system/data_pipe.h"
 
 namespace mojo {
 namespace edk {
 
 namespace {
 
 struct SerializedState {
   MojoCreateDataPipeOptions options;
   uint64_t pipe_id;
   bool peer_closed;
@@ skipping 45 matching lines @@
 Dispatcher::Type DataPipeProducerDispatcher::GetType() const {
   return Type::DATA_PIPE_PRODUCER;
 }
 
 MojoResult DataPipeProducerDispatcher::Close() {
   base::AutoLock lock(lock_);
   DVLOG(1) << "Closing data pipe producer " << pipe_id_;
   return CloseNoLock();
 }
 
+MojoResult DataPipeProducerDispatcher::Watch(
+    MojoHandleSignals signals,
+    const Watcher::WatchCallback& callback,
+    uintptr_t context) {
+  base::AutoLock lock(lock_);
+
+  if (is_closed_ || in_transit_)
+    return MOJO_RESULT_INVALID_ARGUMENT;
+
+  return awakable_list_.AddWatcher(
+      signals, callback, context, GetHandleSignalsStateNoLock());
+}
+
+MojoResult DataPipeProducerDispatcher::CancelWatch(uintptr_t context) {
+  base::AutoLock lock(lock_);
+
+  if (is_closed_ || in_transit_)
+    return MOJO_RESULT_INVALID_ARGUMENT;
+
+  return awakable_list_.RemoveWatcher(context);
+}
+
 MojoResult DataPipeProducerDispatcher::WriteData(const void* elements,
                                                  uint32_t* num_bytes,
                                                  MojoWriteDataFlags flags) {
   base::AutoLock lock(lock_);
   if (!shared_ring_buffer_ || in_transit_)
     return MOJO_RESULT_INVALID_ARGUMENT;
 
   if (in_two_phase_write_)
     return MOJO_RESULT_BUSY;
 
@@ skipping 347 matching lines @@
   // to ignore.
   if (transferred_)
     return;
 
   DVLOG(1) << "Control port status changed for data pipe producer " << pipe_id_;
 
   UpdateSignalsStateNoLock();
 }
 
 void DataPipeProducerDispatcher::UpdateSignalsStateNoLock() {
+  RequestContext request_context;
+
   lock_.AssertAcquired();
 
   bool was_peer_closed = peer_closed_;
   size_t previous_capacity = available_capacity_;
 
   ports::PortStatus port_status;
   if (node_controller_->node()->GetStatus(control_port_, &port_status) !=
           ports::OK ||
       !port_status.receiving_messages) {
     DVLOG(1) << "Data pipe producer " << pipe_id_ << " is aware of peer closure"
@@ skipping 37 matching lines @@
   }
 
   if (peer_closed_ != was_peer_closed ||
       available_capacity_ != previous_capacity) {
     awakable_list_.AwakeForStateChange(GetHandleSignalsStateNoLock());
   }
 }
 
 }  // namespace edk
 }  // namespace mojo