Mojo C++ bindings: refactor SyncHandleWatcher.

mojo/public/cpp/bindings/lib/connector.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_PUBLIC_CPP_BINDINGS_LIB_CONNECTOR_H_
 #define MOJO_PUBLIC_CPP_BINDINGS_LIB_CONNECTOR_H_
 
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
 #include "base/threading/thread_checker.h"
 #include "mojo/public/cpp/bindings/callback.h"
+#include "mojo/public/cpp/bindings/lib/sync_handle_watcher.h"
 #include "mojo/public/cpp/bindings/message.h"
 #include "mojo/public/cpp/system/core.h"
 #include "mojo/public/cpp/system/watcher.h"
 
 namespace base {
 class Lock;
 }
 
 namespace mojo {
 namespace internal {
@@ skipping 89 matching lines @@
   void ResumeIncomingMethodCallProcessing();
 
   // MessageReceiver implementation:
   bool Accept(Message* message) override;
 
   MessagePipeHandle handle() const {
     DCHECK(thread_checker_.CalledOnValidThread());
     return message_pipe_.get();
   }
 
-  // Requests to register |message_pipe_| with SyncHandleWatcher whenever this
-  // instance is expecting incoming messages.
-  //
-  // Please note that UnregisterSyncHandleWatch() needs to be called as many
-  // times as successful RegisterSyncHandleWatch() calls in order to cancel the
-  // effect.
-  bool RegisterSyncHandleWatch();
-  void UnregisterSyncHandleWatch();
+  // Allows |message_pipe_| be watched while others perform sync handle watching
+  // on the same thread. Please see comments of
+  // SyncHandleWatcher::AllowWokenUpBySyncWatchOnSameThread().
+  void AllowWokenUpBySyncWatchOnSameThread();
 
-  // Watches all handles registered with SyncHandleWatcher on the same thread.
-  // The method returns true when |*should_stop| is set to true; returns false
-  // when any failure occurs during the watch, including |message_pipe_| is
-  // closed.
-  bool RunSyncHandleWatch(const bool* should_stop);
+  // Watches |message_pipe_| (as well as other handles registered to be watched
+  // together) synchronously.
+  // This method:
+  //   - returns true when |should_stop| is set to true;
+  //   - return false when any error occurs, including |message_pipe_| being
+  //     closed.
+  bool SyncWatch(const bool* should_stop);
 
   // Whether currently the control flow is inside the sync handle watcher
   // callback.
   bool during_sync_handle_watcher_callback() const {
     return sync_handle_watcher_callback_count_ > 0;
   }
 
  private:
   // Callback of mojo::Watcher.
   void OnWatcherHandleReady(MojoResult result);
@@ skipping 11 matching lines @@
 
   // If |force_pipe_reset| is true, this method replaces the existing
   // |message_pipe_| with a dummy message pipe handle (whose peer is closed).
   // If |force_async_handler| is true, |connection_error_handler_| is called
   // asynchronously.
   void HandleError(bool force_pipe_reset, bool force_async_handler);
 
   // Cancels any calls made to |waiter_|.
   void CancelWait();
 
+  void EnsureSyncWatcherExists();
+
   Closure connection_error_handler_;
 
   ScopedMessagePipeHandle message_pipe_;
   MessageReceiver* incoming_receiver_;
 
   Watcher handle_watcher_;
 
   bool error_;
   bool drop_writes_;
   bool enforce_errors_from_incoming_receiver_;
 
   bool paused_;
 
   // If sending messages is allowed from multiple threads, |lock_| is used to
   // protect modifications to |message_pipe_| and |drop_writes_|.
   scoped_ptr<base::Lock> lock_;
 
-  // If non-zero, |message_pipe_| should be registered with SyncHandleWatcher.
-  size_t register_sync_handle_watch_count_;
-  // Whether |message_pipe_| has been registered with SyncHandleWatcher.
-  bool registered_with_sync_handle_watcher_;
+  scoped_ptr<SyncHandleWatcher> sync_watcher_;
+  bool allow_woken_up_by_others_;
   // If non-zero, currently the control flow is inside the sync handle watcher
   // callback.
   size_t sync_handle_watcher_callback_count_;
-  scoped_refptr<base::RefCountedData<bool>> should_stop_sync_handle_watch_;
 
   base::ThreadChecker thread_checker_;
 
   // Create a single weak ptr and use it everywhere, to avoid the malloc/free
   // cost of creating a new weak ptr whenever it is needed.
   base::WeakPtr<Connector> weak_self_;
   base::WeakPtrFactory<Connector> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(Connector);
 };
 
 }  // namespace internal
 }  // namespace mojo
 
 #endif  // MOJO_PUBLIC_CPP_BINDINGS_LIB_CONNECTOR_H_