Revert of [mojo-bindings] Use Watch API instead of MessagePumpMojo

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/message_pump/handle_watcher.h"
 #include "mojo/public/cpp/bindings/callback.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 {
 
 // The Connector class is responsible for performing read/write operations on a
 // MessagePipe. It writes messages it receives through the MessageReceiver
@@ skipping 108 matching lines @@
   // closed.
   bool RunSyncHandleWatch(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);
+  // Callback of mojo::common::HandleWatcher.
+  void OnHandleWatcherHandleReady(MojoResult result);
   // Callback of SyncHandleWatcher.
   void OnSyncHandleWatcherHandleReady(MojoResult result);
   void OnHandleReadyInternal(MojoResult result);
 
   void WaitToReadMore();
 
   // Returns false if |this| was destroyed during message dispatch.
   WARN_UNUSED_RESULT bool ReadSingleMessage(MojoResult* read_result);
 
   // |this| can be destroyed during message dispatch.
   void ReadAllAvailableMessages();
 
   // 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();
 
   Closure connection_error_handler_;
 
   ScopedMessagePipeHandle message_pipe_;
   MessageReceiver* incoming_receiver_;
 
-  Watcher handle_watcher_;
+  common::HandleWatcher 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_;
@@ skipping 11 matching lines @@
 
   base::WeakPtrFactory<Connector> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(Connector);
 };
 
 }  // namespace internal
 }  // namespace mojo
 
 #endif  // MOJO_PUBLIC_CPP_BINDINGS_LIB_CONNECTOR_H_