Revert "Mojo: Add BindingsSupportImpl on top of HandleWatcher"

mojo/common/handle_watcher.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/common/handle_watcher.h"
 
 #include <map>
 #include <set>
 #include <vector>
 
@@ skipping 29 matching lines @@
   // Returns the shared instance.
   static WatcherThreadManager* GetInstance();
 
   // Starts watching the requested handle. Returns a unique ID that is used to
   // stop watching the handle. When the handle is ready |callback| is notified
   // on the thread StartWatching() was invoked on.
   // This may be invoked on any thread.
   WatcherID StartWatching(MojoHandle handle,
                           MojoWaitFlags wait_flags,
                           base::TimeTicks deadline,
-                          const base::Callback<void(MojoResult)>& callback);
+                          const base::Closure& callback);
 
   // Stops watching a handle.
   void StopWatching(WatcherID watcher_id);
 
  private:
   friend struct base::DefaultLazyInstanceTraits<WatcherThreadManager>;
 
   // Tracks a single request.
   struct HandleAndCallback {
     HandleAndCallback()
         : handle(MOJO_HANDLE_INVALID),
           wait_flags(MOJO_WAIT_FLAG_NONE),
           message_loop(NULL) {}
 
     MojoHandle handle;
     MojoWaitFlags wait_flags;
     base::TimeTicks deadline;
-    base::Callback<void(MojoResult)> callback;
+    base::Closure callback;
     scoped_refptr<base::MessageLoopProxy> message_loop;
   };
 
   // Contains the state needed for MojoWaitMany.
   // NOTE: |handles| and |wait_flags| are separate vectors to make it easy to
   // pass to MojoWaitMany.
   struct WaitState {
     // List of ids.
     std::vector<WatcherID> ids;
 
@@ skipping 52 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(WatcherThreadManager);
 };
 
 WatcherThreadManager* WatcherThreadManager::GetInstance() {
   static base::LazyInstance<WatcherThreadManager> instance =
       LAZY_INSTANCE_INITIALIZER;
   return &instance.Get();
 }
 
-WatcherID WatcherThreadManager::StartWatching(
-    MojoHandle handle,
-    MojoWaitFlags wait_flags,
-    base::TimeTicks deadline,
-    const base::Callback<void(MojoResult)>& callback) {
+WatcherID WatcherThreadManager::StartWatching(MojoHandle handle,
+                                              MojoWaitFlags wait_flags,
+                                              base::TimeTicks deadline,
+                                              const base::Closure& callback) {
   WatcherID id = 0;
   {
     static int next_id = 0;
     base::AutoLock lock(lock_);
     // TODO(sky): worry about overflow?
     id = ++next_id;
     id_to_callback_[id].handle = handle;
     id_to_callback_[id].callback = callback;
     id_to_callback_[id].wait_flags = wait_flags;
     id_to_callback_[id].deadline = deadline;
@@ skipping 102 matching lines @@
 void WatcherThreadManager::RemoveAndNotify(WatcherID id, MojoResult result) {
   HandleAndCallback to_notify;
   {
     base::AutoLock lock(lock_);
     IDToCallbackMap::iterator i = id_to_callback_.find(id);
     if (i == id_to_callback_.end())
       return;
     to_notify = i->second;
     id_to_callback_.erase(i);
   }
-  to_notify.message_loop->PostTask(FROM_HERE,
-                                   base::Bind(to_notify.callback, result));
+  to_notify.message_loop->PostTask(FROM_HERE, to_notify.callback);
 }
 
 void WatcherThreadManager::RemoveHandle(MojoHandle handle) {
   {
     base::AutoLock lock(lock_);
     for (IDToCallbackMap::iterator i = id_to_callback_.begin();
          i != id_to_callback_.end(); ) {
       if (i->second.handle == handle) {
         id_to_callback_.erase(i++);
       } else {
@@ skipping 43 matching lines @@
   explicit StartState(HandleWatcher* watcher) : weak_factory(watcher) {
   }
 
   ~StartState() {
   }
 
   // ID assigned by WatcherThreadManager.
   WatcherID watcher_id;
 
   // Callback to notify when done.
-  base::Callback<void(MojoResult)> callback;
+  base::Closure callback;
 
   // When Start() is invoked a callback is passed to WatcherThreadManager
   // using a WeakRef from |weak_refactory_|. The callback invokes
   // OnHandleReady() (on the thread Start() is invoked from) which in turn
   // notifies |callback_|. Doing this allows us to reset state when the handle
   // is ready, and then notify the callback. Doing this also means Stop()
   // cancels any pending callbacks that may be inflight.
   base::WeakPtrFactory<HandleWatcher> weak_factory;
 };
 
 // HandleWatcher ---------------------------------------------------------------
 
 // static
 base::TickClock* HandleWatcher::tick_clock_ = NULL;
 
 HandleWatcher::HandleWatcher() {
 }
 
 HandleWatcher::~HandleWatcher() {
   Stop();
 }
 
 void HandleWatcher::Start(MojoHandle handle,
                           MojoWaitFlags wait_flags,
                           MojoDeadline deadline,
-                          const base::Callback<void(MojoResult)>& callback) {
+                          const base::Closure& callback) {
   DCHECK_NE(MOJO_HANDLE_INVALID, handle);
   DCHECK_NE(MOJO_WAIT_FLAG_NONE, wait_flags);
 
   Stop();
 
   start_state_.reset(new StartState(this));
   start_state_->callback = callback;
   start_state_->watcher_id =
       WatcherThreadManager::GetInstance()->StartWatching(
           handle,
           wait_flags,
           MojoDeadlineToTimeTicks(deadline),
           base::Bind(&HandleWatcher::OnHandleReady,
                      start_state_->weak_factory.GetWeakPtr()));
 }
 
 void HandleWatcher::Stop() {
   if (!start_state_.get())
     return;
 
   scoped_ptr<StartState> old_state(start_state_.Pass());
   WatcherThreadManager::GetInstance()->StopWatching(old_state->watcher_id);
 }
 
-void HandleWatcher::OnHandleReady(MojoResult result) {
+void HandleWatcher::OnHandleReady() {
   DCHECK(start_state_.get());
   scoped_ptr<StartState> old_state(start_state_.Pass());
-  old_state->callback.Run(result);
-
-  // NOTE: We may have been deleted during callback execution.
+  old_state->callback.Run();
 }
 
 // static
 base::TimeTicks HandleWatcher::NowTicks() {
   return tick_clock_ ? tick_clock_->NowTicks() : base::TimeTicks::Now();
 }
 
 // static
 base::TimeTicks HandleWatcher::MojoDeadlineToTimeTicks(MojoDeadline deadline) {
   return deadline == MOJO_DEADLINE_INDEFINITE ? base::TimeTicks() :
       NowTicks() + base::TimeDelta::FromMicroseconds(deadline);
 }
 
 }  // namespace common
 }  // namespace mojo