Mojo: Armed Watchers

mojo/edk/system/core.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/core.h"
 
 #include <string.h>
 
 #include <utility>
 
@@ skipping 409 matching lines @@
     // Note: The |reinterpret_cast| is safe, since |HandleSignalsState| is a
     // subclass of |MojoHandleSignalsState| that doesn't add any data members.
     rv = WaitManyInternal(handles, signals, num_handles, deadline, &index,
                           reinterpret_cast<HandleSignalsState*>(signals_state));
   }
   if (index != static_cast<uint32_t>(-1) && result_index)
     *result_index = index;
   return rv;
 }
 
-MojoResult Core::Watch(MojoHandle handle,
-                       MojoHandleSignals signals,
-                       MojoWatchCallback callback,
-                       uintptr_t context) {
+MojoResult Core::RegisterWatcher(MojoHandle handle,
+                                 MojoHandleSignals signals,
+                                 MojoWatchCallback callback,
+                                 uintptr_t context) {
   RequestContext request_context;
   scoped_refptr<Dispatcher> dispatcher = GetDispatcher(handle);
   if (!dispatcher)
     return MOJO_RESULT_INVALID_ARGUMENT;
-  return dispatcher->Watch(
+  return dispatcher->RegisterWatcher(
       signals, base::Bind(&CallWatchCallback, callback, context), context);
 }
 
-MojoResult Core::CancelWatch(MojoHandle handle, uintptr_t context) {
+MojoResult Core::ArmWatcher(MojoHandle handle, uintptr_t context) {
   RequestContext request_context;
   scoped_refptr<Dispatcher> dispatcher = GetDispatcher(handle);
   if (!dispatcher)
     return MOJO_RESULT_INVALID_ARGUMENT;
-  return dispatcher->CancelWatch(context);
+  return dispatcher->ArmWatcher(context);
+}
+
+MojoResult Core::UnregisterWatcher(MojoHandle handle, uintptr_t context) {
+  RequestContext request_context;
+  scoped_refptr<Dispatcher> dispatcher = GetDispatcher(handle);
+  if (!dispatcher)
+    return MOJO_RESULT_INVALID_ARGUMENT;
+  return dispatcher->UnregisterWatcher(context);
 }
 
 MojoResult Core::AllocMessage(uint32_t num_bytes,
                               const MojoHandle* handles,
                               uint32_t num_handles,
                               MojoAllocMessageFlags flags,
                               MojoMessageHandle* message) {
   if (!message)
     return MOJO_RESULT_INVALID_ARGUMENT;
 
@@ skipping 711 matching lines @@
     std::unique_ptr<NodeController> node_controller) {
   // It's OK to leak this reference. At this point we know the IO loop is still
   // running, and we know the NodeController will observe its eventual
   // destruction. This tells the NodeController to delete itself when that
   // happens.
   node_controller.release()->DestroyOnIOThreadShutdown();
 }
 
 }  // namespace edk
 }  // namespace mojo