Revert making HandleWatcher block until no longer waiting on pipe (r285266).

mojo/message_pump/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/message_pump/handle_watcher.h"
 
 #include <map>
 
 #include "base/atomic_sequence_num.h"
 #include "base/bind.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/memory/singleton.h"
 #include "base/memory/weak_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/profiler/scoped_tracker.h"
 #include "base/single_thread_task_runner.h"
 #include "base/synchronization/lock.h"
-#include "base/synchronization/waitable_event.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/threading/thread.h"
-#include "base/threading/thread_restrictions.h"
 #include "base/time/time.h"
 #include "mojo/message_pump/message_pump_mojo.h"
 #include "mojo/message_pump/message_pump_mojo_handler.h"
 #include "mojo/message_pump/time_helper.h"
 
 namespace mojo {
 namespace common {
 
 typedef int WatcherID;
 
@@ skipping 23 matching lines @@
 
 // WatcherBackend is responsible for managing the requests and interacting with
 // MessagePumpMojo. All access (outside of creation/destruction) is done on the
 // thread WatcherThreadManager creates.
 class WatcherBackend : public MessagePumpMojoHandler {
  public:
   WatcherBackend();
   ~WatcherBackend() override;
 
   void StartWatching(const WatchData& data);
-
-  // Cancels a previously scheduled request to start a watch.
   void StopWatching(WatcherID watcher_id);
 
  private:
   typedef std::map<Handle, WatchData> HandleToWatchDataMap;
 
   // Invoked when a handle needs to be removed and notified.
   void RemoveAndNotify(const Handle& handle, MojoResult result);
 
   // Searches through |handle_to_data_| for |watcher_id|. Returns true if found
   // and sets |handle| to the Handle. Returns false if not a known id.
@@ skipping 23 matching lines @@
   handle_to_data_[data.handle] = data;
   MessagePumpMojo::current()->AddHandler(this, data.handle,
                                          data.handle_signals,
                                          data.deadline);
 }
 
 void WatcherBackend::StopWatching(WatcherID watcher_id) {
   // Because of the thread hop it is entirely possible to get here and not
   // have a valid handle registered for |watcher_id|.
   Handle handle;
-  if (GetMojoHandleByWatcherID(watcher_id, &handle)) {
-    handle_to_data_.erase(handle);
-    MessagePumpMojo::current()->RemoveHandler(handle);
-  }
+  if (!GetMojoHandleByWatcherID(watcher_id, &handle))
+    return;
+
+  handle_to_data_.erase(handle);
+  MessagePumpMojo::current()->RemoveHandler(handle);
 }
 
 void WatcherBackend::RemoveAndNotify(const Handle& handle,
                                      MojoResult result) {
   if (handle_to_data_.count(handle) == 0)
     return;
 
   const WatchData data(handle_to_data_[handle]);
   handle_to_data_.erase(handle);
   MessagePumpMojo::current()->RemoveHandler(handle);
@@ skipping 18 matching lines @@
 }
 
 void WatcherBackend::OnHandleError(const Handle& handle, MojoResult result) {
   RemoveAndNotify(handle, result);
 }
 
 // WatcherThreadManager --------------------------------------------------------
 
 // WatcherThreadManager manages the background thread that listens for handles
 // to be ready. All requests are handled by WatcherBackend.
-}  // namespace
-
 class WatcherThreadManager {
  public:
   ~WatcherThreadManager();
 
   // 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(const Handle& handle,
                           MojoHandleSignals handle_signals,
                           base::TimeTicks deadline,
                           const base::Callback<void(MojoResult)>& callback);
 
   // Stops watching a handle.
   // This may be invoked on any thread.
   void StopWatching(WatcherID watcher_id);
 
  private:
   enum RequestType {
     REQUEST_START,
     REQUEST_STOP,
   };
 
   // See description of |requests_| for details.
   struct RequestData {
-    RequestData() : type(REQUEST_START), stop_id(0), stop_event(NULL) {}
+    RequestData() : type(REQUEST_START), stop_id(0) {}
 
     RequestType type;
     WatchData start_data;
     WatcherID stop_id;
-    base::WaitableEvent* stop_event;
   };
 
   typedef std::vector<RequestData> Requests;
 
   friend struct base::DefaultSingletonTraits<WatcherThreadManager>;
 
   WatcherThreadManager();
 
   // Schedules a request on the background thread. See |requests_| for details.
   void AddRequest(const RequestData& data);
@@ skipping 55 matching lines @@
         return;
       }
     }
   }
 
   // TODO(amistry): Remove ScopedTracker below once http://crbug.com/554761 is
   // fixed.
   tracked_objects::ScopedTracker tracking_profile(
       FROM_HERE_WITH_EXPLICIT_FUNCTION(
           "554761 WatcherThreadManager::StopWatching"));
-  base::ThreadRestrictions::ScopedAllowWait allow_wait;
-  base::WaitableEvent event(true, false);
   RequestData request_data;
   request_data.type = REQUEST_STOP;
   request_data.stop_id = watcher_id;
-  request_data.stop_event = &event;
   AddRequest(request_data);
-
-  // We need to block until the handle is actually removed.
-  event.Wait();
 }
 
 void WatcherThreadManager::AddRequest(const RequestData& data) {
   {
     base::AutoLock auto_lock(lock_);
     const bool was_empty = requests_.empty();
     requests_.push_back(data);
     if (!was_empty)
       return;
   }
-  // We own |thread_|, so it's safe to use Unretained() here.
+  // We outlive |thread_|, so it's safe to use Unretained() here.
   thread_.task_runner()->PostTask(
       FROM_HERE,
       base::Bind(&WatcherThreadManager::ProcessRequestsOnBackendThread,
                  base::Unretained(this)));
 }
 
 void WatcherThreadManager::ProcessRequestsOnBackendThread() {
   DCHECK_EQ(thread_.message_loop(), base::MessageLoop::current());
 
   Requests requests;
   {
     base::AutoLock auto_lock(lock_);
     requests_.swap(requests);
   }
   for (size_t i = 0; i < requests.size(); ++i) {
     if (requests[i].type == REQUEST_START) {
       backend_.StartWatching(requests[i].start_data);
     } else {
       backend_.StopWatching(requests[i].stop_id);
-      requests[i].stop_event->Signal();
     }
   }
 }
 
 WatcherThreadManager::WatcherThreadManager()
     : thread_(kWatcherThreadName) {
   base::Thread::Options thread_options;
   thread_options.message_pump_factory = base::Bind(&MessagePumpMojo::Create);
   thread_.StartWithOptions(thread_options);
 }
 
+}  // namespace
+
 // HandleWatcher::StateBase and subclasses -------------------------------------
 
 // The base class of HandleWatcher's state. Owns the user's callback and
 // monitors the current thread's MessageLoop to know when to force the callback
 // to run (with an error) even though the pipe hasn't been signaled yet.
 class HandleWatcher::StateBase : public base::MessageLoop::DestructionObserver {
  public:
   StateBase(HandleWatcher* watcher,
             const base::Callback<void(MojoResult)>& callback)
       : watcher_(watcher),
@@ skipping 145 matching lines @@
         this, handle, handle_signals, deadline, callback));
   }
 }
 
 void HandleWatcher::Stop() {
   state_.reset();
 }
 
 }  // namespace common
 }  // namespace mojo