Revert 111865 - Remove several more custom Task implementations from base/

BUG=none
TEST=trybots

Review URL: http://codereview.chromium.org/8702016

TBR=dcheng@chromium.org
Review URL: http://codereview.chromium.org/8729020

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@111868 0039d316-1c4b-4281-b951-d872f2087c98

2 files changed, 70 insertions, 40 deletions

diff --git a/base/win/object_watcher.cc b/base/win/object_watcher.cc
index be1e409..4f5e7ab 100644
--- a/base/win/object_watcher.cc
+++ b/base/win/object_watcher.cc
@@ -4,7 +4,6 @@
 
 #include "base/win/object_watcher.h"
 
-#include "base/bind.h"
 #include "base/logging.h"
 
 namespace base {
@@ -12,12 +11,30 @@ namespace win {
 
 //-----------------------------------------------------------------------------
 
-ObjectWatcher::ObjectWatcher()
-    : weak_factory_(this),
-      object_(NULL),
-      wait_object_(NULL),
-      origin_loop_(NULL),
-      delegate_(NULL) {
+struct ObjectWatcher::Watch : public Task {
+  ObjectWatcher* watcher;    // The associated ObjectWatcher instance
+  HANDLE object;             // The object being watched
+  HANDLE wait_object;        // Returned by RegisterWaitForSingleObject
+  MessageLoop* origin_loop;  // Used to get back to the origin thread
+  Delegate* delegate;        // Delegate to notify when signaled
+  bool did_signal;           // DoneWaiting was called
+
+  virtual void Run() {
+    // The watcher may have already been torn down, in which case we need to
+    // just get out of dodge.
+    if (!watcher)
+      return;
+
+    DCHECK(did_signal);
+    watcher->StopWatching();
+
+    delegate->OnObjectSignaled(object);
+  }
+};
+
+//-----------------------------------------------------------------------------
+
+ObjectWatcher::ObjectWatcher() : watch_(NULL) {
 }
 
 ObjectWatcher::~ObjectWatcher() {
@@ -25,25 +42,30 @@ ObjectWatcher::~ObjectWatcher() {
 }
 
 bool ObjectWatcher::StartWatching(HANDLE object, Delegate* delegate) {
-  if (wait_object_) {
+  if (watch_) {
     NOTREACHED() << "Already watching an object";
     return false;
   }
 
-  origin_loop_ = MessageLoop::current();
-  delegate_ = delegate;
+  Watch* watch = new Watch;
+  watch->watcher = this;
+  watch->object = object;
+  watch->origin_loop = MessageLoop::current();
+  watch->delegate = delegate;
+  watch->did_signal = false;
 
   // Since our job is to just notice when an object is signaled and report the
   // result back to this thread, we can just run on a Windows wait thread.
   DWORD wait_flags = WT_EXECUTEINWAITTHREAD | WT_EXECUTEONLYONCE;
 
-  if (!RegisterWaitForSingleObject(&wait_object_, object, DoneWaiting,
-                                   this, INFINITE, wait_flags)) {
+  if (!RegisterWaitForSingleObject(&watch->wait_object, object, DoneWaiting,
+                                   watch, INFINITE, wait_flags)) {
     NOTREACHED() << "RegisterWaitForSingleObject failed: " << GetLastError();
+    delete watch;
     return false;
   }
 
-  object_ = object;
+  watch_ = watch;
 
   // We need to know if the current message loop is going away so we can
   // prevent the wait thread from trying to access a dead message loop.
@@ -52,46 +74,60 @@ bool ObjectWatcher::StartWatching(HANDLE object, Delegate* delegate) {
 }
 
 bool ObjectWatcher::StopWatching() {
-  if (!wait_object_)
+  if (!watch_)
     return false;
 
   // Make sure ObjectWatcher is used in a single-threaded fashion.
-  DCHECK(origin_loop_ == MessageLoop::current());
+  DCHECK(watch_->origin_loop == MessageLoop::current());
 
-  // Blocking call to cancel the wait. Any callbacks already in progress will
-  // finish before we return from this call.
-  if (!UnregisterWaitEx(wait_object_, INVALID_HANDLE_VALUE)) {
+  // If DoneWaiting is in progress, we wait for it to finish.  We know whether
+  // DoneWaiting happened or not by inspecting the did_signal flag.
+  if (!UnregisterWaitEx(watch_->wait_object, INVALID_HANDLE_VALUE)) {
     NOTREACHED() << "UnregisterWaitEx failed: " << GetLastError();
     return false;
   }
 
-  weak_factory_.InvalidateWeakPtrs();
-  object_ = NULL;
-  wait_object_ = NULL;
+  // Make sure that we see any mutation to did_signal.  This should be a no-op
+  // since we expect that UnregisterWaitEx resulted in a memory barrier, but
+  // just to be sure, we're going to be explicit.
+  MemoryBarrier();
+
+  // If the watch has been posted, then we need to make sure it knows not to do
+  // anything once it is run.
+  watch_->watcher = NULL;
+
+  // If DoneWaiting was called, then the watch would have been posted as a
+  // task, and will therefore be deleted by the MessageLoop.  Otherwise, we
+  // need to take care to delete it here.
+  if (!watch_->did_signal)
+    delete watch_;
+
+  watch_ = NULL;
 
   MessageLoop::current()->RemoveDestructionObserver(this);
   return true;
 }
 
 HANDLE ObjectWatcher::GetWatchedObject() {
-  return object_;
+  if (!watch_)
+    return NULL;
+
+  return watch_->object;
 }
 
 // static
 void CALLBACK ObjectWatcher::DoneWaiting(void* param, BOOLEAN timed_out) {
   DCHECK(!timed_out);
 
-  // The destructor blocks on any callbacks that are in flight, so we know that
-  // that is always a pointer to a valid ObjectWater.
-  ObjectWatcher* that = static_cast<ObjectWatcher*>(param);
-  that->origin_loop_->PostTask(
-      FROM_HERE,
-      base::Bind(&ObjectWatcher::Signal, that->weak_factory_.GetWeakPtr()));
-}
+  Watch* watch = static_cast<Watch*>(param);
 
-void ObjectWatcher::Signal() {
-  StopWatching();
-  delegate_->OnObjectSignaled(object_);
+  // Record that we ran this function.
+  watch->did_signal = true;
+
+  // We rely on the locking in PostTask() to ensure that a memory barrier is
+  // provided, which in turn ensures our change to did_signal can be observed
+  // on the target thread.
+  watch->origin_loop->PostTask(FROM_HERE, watch);
 }
 
 void ObjectWatcher::WillDestroyCurrentMessageLoop() {
diff --git a/base/win/object_watcher.h b/base/win/object_watcher.h
index 86ac2d0..f5a46eb 100644
--- a/base/win/object_watcher.h
+++ b/base/win/object_watcher.h
@@ -9,7 +9,6 @@
 #include <windows.h>
 
 #include "base/base_export.h"
-#include "base/memory/weak_ptr.h"
 #include "base/message_loop.h"
 
 namespace base {
@@ -80,17 +79,12 @@ class BASE_EXPORT ObjectWatcher : public MessageLoop::DestructionObserver {
   // Called on a background thread when done waiting.
   static void CALLBACK DoneWaiting(void* param, BOOLEAN timed_out);
 
-  void Signal();
-
   // MessageLoop::DestructionObserver implementation:
   virtual void WillDestroyCurrentMessageLoop();
 
   // Internal state.
-  base::WeakPtrFactory<ObjectWatcher> weak_factory_;
-  HANDLE object_;             // The object being watched
-  HANDLE wait_object_;        // Returned by RegisterWaitForSingleObject
-  MessageLoop* origin_loop_;  // Used to get back to the origin thread
-  Delegate* delegate_;        // Delegate to notify when signaled
+  struct Watch;
+  Watch* watch_;
 
   DISALLOW_COPY_AND_ASSIGN(ObjectWatcher);
 };