[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>
@@ skipping 61 matching lines @@
   if (initialized) {
     base::AutoLock lock(lock_);
     InitializeNoLock();
   }
 }
 
 Dispatcher::Type DataPipeProducerDispatcher::GetType() const {
   return Type::DATA_PIPE_PRODUCER;
 }
 
-MojoResult DataPipeProducerDispatcher::Close() {
+MojoResult DataPipeProducerDispatcher::Close(RequestContext* request_context) {
   base::AutoLock lock(lock_);
   DVLOG(1) << "Closing data pipe producer " << pipe_id_;
   return CloseNoLock();
 }
 
 MojoResult DataPipeProducerDispatcher::WriteData(const void* elements,
                                                  uint32_t* num_bytes,
                                                  MojoWriteDataFlags flags) {
   base::AutoLock lock(lock_);
   if (!shared_ring_buffer_ || in_transit_)
@@ skipping 198 matching lines @@
   state->available_capacity = available_capacity_;
 
   ports[0] = control_port_.name();
 
   buffer_handle_for_transit_ = shared_ring_buffer_->DuplicatePlatformHandle();
   platform_handles[0] = buffer_handle_for_transit_.get();
 
   return true;
 }
 
-bool DataPipeProducerDispatcher::BeginTransit() {
+bool DataPipeProducerDispatcher::BeginTransit(RequestContext* request_context) {
   base::AutoLock lock(lock_);
   if (in_transit_)
     return false;
   in_transit_ = !in_two_phase_write_;
   return in_transit_;
 }
 
-void DataPipeProducerDispatcher::CompleteTransitAndClose() {
+void DataPipeProducerDispatcher::CompleteTransitAndClose(
+    RequestContext* request_context) {
   node_controller_->SetPortObserver(control_port_, nullptr);
 
   base::AutoLock lock(lock_);
   DCHECK(in_transit_);
   transferred_ = true;
   in_transit_ = false;
   ignore_result(buffer_handle_for_transit_.release());
   CloseNoLock();
 }
 
-void DataPipeProducerDispatcher::CancelTransit() {
+void DataPipeProducerDispatcher::CancelTransit(
+    RequestContext* request_context) {
   base::AutoLock lock(lock_);
   DCHECK(in_transit_);
   in_transit_ = false;
   buffer_handle_for_transit_.reset();
   awakable_list_.AwakeForStateChange(GetHandleSignalsStateNoLock());
 }
 
 // static
 scoped_refptr<DataPipeProducerDispatcher>
 DataPipeProducerDispatcher::Deserialize(const void* data,
@@ skipping 171 matching lines @@
   }
 
   if (peer_closed_ != was_peer_closed ||
       available_capacity_ != previous_capacity) {
     awakable_list_.AwakeForStateChange(GetHandleSignalsStateNoLock());
   }
 }
 
 }  // namespace edk
 }  // namespace mojo