Revert 179987

Caused memory leak:
Leak_DefinitelyLost
4,196 (1,600 direct, 2,596 indirect) bytes in 4 blocks are definitely lost in loss record 608 of 639
  operator new(unsigned long) (m_replacemalloc/vg_replace_malloc.c:1140)
  IPC::SyncChannel::SyncChannel(IPC::ChannelHandle const&, IPC::Channel::Mode, IPC::Listener*, base::SingleThreadTaskRunner*, bool, base::WaitableEvent*) (ipc/ipc_sync_channel.cc:410)
  (anonymous namespace)::RestrictedDispatchPipeWorker::Run() (ipc/ipc_sync_channel_unittest.cc:1636)
  (anonymous namespace)::Worker::OnStart() (ipc/ipc_sync_channel_unittest.cc:176)
Suppression (error hash=#2A77226DFEFF6041#):
  For more info on using suppressions see http://dev.chromium.org/developers/tree-sheriffs/sheriff-details-chromium/memory-sheriff#TOC-Suppressing-memory-reports
{
   <insert_a_suppression_name_here>
   Memcheck:Leak
   fun:_Znw*
   fun:_ZN3IPC11SyncChannelC1ERKNS_13ChannelHandleENS_7Channel4ModeEPNS_8ListenerEPN4base22SingleThreadTaskRunnerEbPNS8_13WaitableEventE
   fun:_ZN12_GLOBAL__N_128RestrictedDispatchPipeWorker3RunEv
   fun:_ZN12_GLOBAL__N_16Worker7OnStartEv
}

15:02:51 memcheck_a
http://build.chromium.org/p/chromium.memory.fyi/builders/Chromium%20OS%20%28valgrind%29%282%29/builds/22101

> Refactor: Simplify WaitableEventWatcher.
> 
> This change uses a callback instead of a delegate for specifying what
> should be called when a WaitableEvent occurs.
> 
> This simplifies the class and gets rid of a workaround internal to the
> class to prevent name collision on "Delegate" inner classes.
> 
> Tested (on linux and windows):
>   ninja -C out/Debug chrome
>   out/Debug/base_unittests --gtest_filter=*WaitableEventWatcherTest*
> 
> BUG=
> 
> 
> Review URL: https://chromiumcodereview.appspot.com/11953112

TBR=teravest@chromium.org
Review URL: https://codereview.chromium.org/12087120

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

11 files changed, 159 insertions, 112 deletions

diff --git a/base/synchronization/waitable_event_watcher.h b/base/synchronization/waitable_event_watcher.h
index fe61f96..f5c1510 100644
--- a/base/synchronization/waitable_event_watcher.h
+++ b/base/synchronization/waitable_event_watcher.h
@@ -23,6 +23,7 @@ class AsyncWaiter;
 class AsyncCallbackTask;
 class WaitableEvent;
 
+// -----------------------------------------------------------------------------
 // This class provides a way to wait on a WaitableEvent asynchronously.
 //
 // Each instance of this object can be waiting on a single WaitableEvent. When
@@ -31,13 +32,12 @@ class WaitableEvent;
 //
 // Typical usage:
 //
-//   class MyClass {
+//   class MyClass : public base::WaitableEventWatcher::Delegate {
 //    public:
 //     void DoStuffWhenSignaled(WaitableEvent *waitable_event) {
-//       watcher_.StartWatching(waitable_event,
-//           base::Bind(&MyClass::OnWaitableEventSignaled, this);
+//       watcher_.StartWatching(waitable_event, this);
 //     }
-//     void OnWaitableEventSignaled(WaitableEvent* waitable_event) {
+//     virtual void OnWaitableEventSignaled(WaitableEvent* waitable_event) {
 //       // OK, time to do stuff!
 //     }
 //    private:
@@ -57,56 +57,106 @@ class WaitableEvent;
 //
 // NOTE: you /are/ allowed to delete the WaitableEvent while still waiting on
 // it with a Watcher. It will act as if the event was never signaled.
+// -----------------------------------------------------------------------------
 
 class BASE_EXPORT WaitableEventWatcher
-#if defined(OS_WIN)
-    : public win::ObjectWatcher::Delegate {
-#else
-    : public MessageLoop::DestructionObserver {
+#if !defined(OS_WIN)
+    : public MessageLoop::DestructionObserver
 #endif
+{
  public:
-  typedef Callback<void(WaitableEvent*)> EventCallback;
+
   WaitableEventWatcher();
   virtual ~WaitableEventWatcher();
 
-  // When @event is signaled, the given callback is called on the thread of the
-  // current message loop when StartWatching is called.
-  bool StartWatching(WaitableEvent* event, const EventCallback& callback);
-
+  class BASE_EXPORT Delegate {
+   public:
+    // -------------------------------------------------------------------------
+    // This is called on the MessageLoop thread when WaitableEvent has been
+    // signaled.
+    //
+    // Note: the event may not be signaled by the time that this function is
+    // called. This indicates only that it has been signaled at some point in
+    // the past.
+    // -------------------------------------------------------------------------
+    virtual void OnWaitableEventSignaled(WaitableEvent* waitable_event) = 0;
+
+   protected:
+    virtual ~Delegate() { }
+  };
+
+  // ---------------------------------------------------------------------------
+  // When @event is signaled, the given delegate is called on the thread of the
+  // current message loop when StartWatching is called. The delegate is not
+  // deleted.
+  // ---------------------------------------------------------------------------
+  bool StartWatching(WaitableEvent* event, Delegate* delegate);
+
+  // ---------------------------------------------------------------------------
   // Cancel the current watch. Must be called from the same thread which
   // started the watch.
   //
   // Does nothing if no event is being watched, nor if the watch has completed.
-  // The callback will *not* be called for the current watch after this
-  // function returns. Since the callback runs on the same thread as this
+  // The delegate will *not* be called for the current watch after this
+  // function returns. Since the delegate runs on the same thread as this
   // function, it cannot be called during this function either.
+  // ---------------------------------------------------------------------------
   void StopWatching();
 
+  // ---------------------------------------------------------------------------
   // Return the currently watched event, or NULL if no object is currently being
   // watched.
+  // ---------------------------------------------------------------------------
   WaitableEvent* GetWatchedEvent();
 
-  // Return the callback that will be invoked when the event is
-  // signaled.
-  const EventCallback& callback() const { return callback_; }
+  // ---------------------------------------------------------------------------
+  // Return the delegate, or NULL if there is no delegate.
+  // ---------------------------------------------------------------------------
+  Delegate* delegate() {
+    return delegate_;
+  }
 
  private:
 #if defined(OS_WIN)
-  virtual void OnObjectSignaled(HANDLE h) OVERRIDE;
+  // ---------------------------------------------------------------------------
+  // The helper class exists because, if WaitableEventWatcher were to inherit
+  // from ObjectWatcher::Delegate, then it couldn't also have an inner class
+  // called Delegate (at least on Windows). Thus this object exists to proxy
+  // the callback function
+  // ---------------------------------------------------------------------------
+  class ObjectWatcherHelper : public win::ObjectWatcher::Delegate {
+   public:
+    ObjectWatcherHelper(WaitableEventWatcher* watcher);
+
+    // -------------------------------------------------------------------------
+    // Implementation of ObjectWatcher::Delegate
+    // -------------------------------------------------------------------------
+    void OnObjectSignaled(HANDLE h);
+
+   private:
+    WaitableEventWatcher *const watcher_;
+  };
+
+  void OnObjectSignaled();
+
+  ObjectWatcherHelper helper_;
   win::ObjectWatcher watcher_;
 #else
+  // ---------------------------------------------------------------------------
   // Implementation of MessageLoop::DestructionObserver
+  // ---------------------------------------------------------------------------
   virtual void WillDestroyCurrentMessageLoop() OVERRIDE;
 
   MessageLoop* message_loop_;
   scoped_refptr<Flag> cancel_flag_;
   AsyncWaiter* waiter_;
-  base::Closure internal_callback_;
+  base::Closure callback_;
   scoped_refptr<WaitableEvent::WaitableEventKernel> kernel_;
 #endif
 
   WaitableEvent* event_;
-  EventCallback callback_;
+
+  Delegate* delegate_;
 };
 
 }  // namespace base
diff --git a/base/synchronization/waitable_event_watcher_posix.cc b/base/synchronization/waitable_event_watcher_posix.cc
index cc2fbc3..3180b4b 100644
--- a/base/synchronization/waitable_event_watcher_posix.cc
+++ b/base/synchronization/waitable_event_watcher_posix.cc
@@ -97,14 +97,14 @@ class AsyncWaiter : public WaitableEvent::Waiter {
 // the event is canceled.
 // -----------------------------------------------------------------------------
 void AsyncCallbackHelper(Flag* flag,
-                         const WaitableEventWatcher::EventCallback& callback,
+                         WaitableEventWatcher::Delegate* delegate,
                          WaitableEvent* event) {
   // Runs in MessageLoop thread.
   if (!flag->value()) {
     // This is to let the WaitableEventWatcher know that the event has occured
     // because it needs to be able to return NULL from GetWatchedObject
     flag->Set();
-    callback.Run(event);
+    delegate->OnWaitableEventSignaled(event);
   }
 }
 
@@ -112,7 +112,8 @@ WaitableEventWatcher::WaitableEventWatcher()
     : message_loop_(NULL),
       cancel_flag_(NULL),
       waiter_(NULL),
-      event_(NULL) {
+      event_(NULL),
+      delegate_(NULL) {
 }
 
 WaitableEventWatcher::~WaitableEventWatcher() {
@@ -123,9 +124,8 @@ WaitableEventWatcher::~WaitableEventWatcher() {
 // The Handle is how the user cancels a wait. After deleting the Handle we
 // insure that the delegate cannot be called.
 // -----------------------------------------------------------------------------
-bool WaitableEventWatcher::StartWatching(
-    WaitableEvent* event,
-    const EventCallback& callback) {
+bool WaitableEventWatcher::StartWatching
+    (WaitableEvent* event, WaitableEventWatcher::Delegate* delegate) {
   MessageLoop *const current_ml = MessageLoop::current();
   DCHECK(current_ml) << "Cannot create WaitableEventWatcher without a "
                         "current MessageLoop";
@@ -145,13 +145,12 @@ bool WaitableEventWatcher::StartWatching(
   DCHECK(!cancel_flag_.get()) << "StartWatching called while still watching";
 
   cancel_flag_ = new Flag;
-  callback_ = callback;
-  internal_callback_ =
-      base::Bind(&AsyncCallbackHelper, cancel_flag_, callback_, event);
+  callback_ = base::Bind(&AsyncCallbackHelper, cancel_flag_, delegate, event);
   WaitableEvent::WaitableEventKernel* kernel = event->kernel_.get();
 
   AutoLock locked(kernel->lock_);
 
+  delegate_ = delegate;
   event_ = event;
 
   if (kernel->signaled_) {
@@ -160,7 +159,7 @@ bool WaitableEventWatcher::StartWatching(
 
     // No hairpinning - we can't call the delegate directly here. We have to
     // enqueue a task on the MessageLoop as normal.
-    current_ml->PostTask(FROM_HERE, internal_callback_);
+    current_ml->PostTask(FROM_HERE, callback_);
     return true;
   }
 
@@ -168,14 +167,14 @@ bool WaitableEventWatcher::StartWatching(
   current_ml->AddDestructionObserver(this);
 
   kernel_ = kernel;
-  waiter_ = new AsyncWaiter(current_ml, internal_callback_, cancel_flag_);
+  waiter_ = new AsyncWaiter(current_ml, callback_, cancel_flag_);
   event->Enqueue(waiter_);
 
   return true;
 }
 
 void WaitableEventWatcher::StopWatching() {
-  callback_.Reset();
+  delegate_ = NULL;
 
   if (message_loop_) {
     message_loop_->RemoveDestructionObserver(this);
@@ -228,7 +227,7 @@ void WaitableEventWatcher::StopWatching() {
     // have been enqueued with the MessageLoop because the waiter was never
     // signaled)
     delete waiter_;
-    internal_callback_.Reset();
+    callback_.Reset();
     cancel_flag_ = NULL;
     return;
   }
diff --git a/base/synchronization/waitable_event_watcher_unittest.cc b/base/synchronization/waitable_event_watcher_unittest.cc
index a35c7c9..03ab800 100644
--- a/base/synchronization/waitable_event_watcher_unittest.cc
+++ b/base/synchronization/waitable_event_watcher_unittest.cc
@@ -2,8 +2,6 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "base/bind.h"
-#include "base/callback.h"
 #include "base/message_loop.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/synchronization/waitable_event_watcher.h"
@@ -25,15 +23,18 @@ const MessageLoop::Type testing_message_loops[] = {
 
 const int kNumTestingMessageLoops = arraysize(testing_message_loops);
 
-void QuitWhenSignaled(WaitableEvent* event) {
-  MessageLoop::current()->QuitWhenIdle();
-}
+class QuitDelegate : public WaitableEventWatcher::Delegate {
+ public:
+  virtual void OnWaitableEventSignaled(WaitableEvent* event) OVERRIDE {
+    MessageLoop::current()->QuitWhenIdle();
+  }
+};
 
-class DecrementCountContainer {
+class DecrementCountDelegate : public WaitableEventWatcher::Delegate {
  public:
-  explicit DecrementCountContainer(int* counter) : counter_(counter) {
+  explicit DecrementCountDelegate(int* counter) : counter_(counter) {
   }
-  void OnWaitableEventSignaled(WaitableEvent* object) {
+  virtual void OnWaitableEventSignaled(WaitableEvent* object) OVERRIDE {
     --(*counter_);
   }
  private:
@@ -49,7 +50,8 @@ void RunTest_BasicSignal(MessageLoop::Type message_loop_type) {
   WaitableEventWatcher watcher;
   EXPECT_TRUE(watcher.GetWatchedEvent() == NULL);
 
-  watcher.StartWatching(&event, Bind(&QuitWhenSignaled));
+  QuitDelegate delegate;
+  watcher.StartWatching(&event, &delegate);
   EXPECT_EQ(&event, watcher.GetWatchedEvent());
 
   event.Signal();
@@ -67,7 +69,8 @@ void RunTest_BasicCancel(MessageLoop::Type message_loop_type) {
 
   WaitableEventWatcher watcher;
 
-  watcher.StartWatching(&event, Bind(&QuitWhenSignaled));
+  QuitDelegate delegate;
+  watcher.StartWatching(&event, &delegate);
 
   watcher.StopWatching();
 }
@@ -81,11 +84,9 @@ void RunTest_CancelAfterSet(MessageLoop::Type message_loop_type) {
   WaitableEventWatcher watcher;
 
   int counter = 1;
-  DecrementCountContainer delegate(&counter);
-  WaitableEventWatcher::EventCallback callback =
-      Bind(&DecrementCountContainer::OnWaitableEventSignaled,
-           Unretained(&delegate));
-  watcher.StartWatching(&event, callback);
+  DecrementCountDelegate delegate(&counter);
+
+  watcher.StartWatching(&event, &delegate);
 
   event.Signal();
 
@@ -110,7 +111,8 @@ void RunTest_OutlivesMessageLoop(MessageLoop::Type message_loop_type) {
     {
       MessageLoop message_loop(message_loop_type);
 
-      watcher.StartWatching(&event, Bind(&QuitWhenSignaled));
+      QuitDelegate delegate;
+      watcher.StartWatching(&event, &delegate);
     }
   }
 }
@@ -125,8 +127,8 @@ void RunTest_DeleteUnder(MessageLoop::Type message_loop_type) {
     WaitableEventWatcher watcher;
 
     WaitableEvent* event = new WaitableEvent(false, false);
-
-    watcher.StartWatching(event, Bind(&QuitWhenSignaled));
+    QuitDelegate delegate;
+    watcher.StartWatching(event, &delegate);
     delete event;
   }
 }
diff --git a/base/synchronization/waitable_event_watcher_win.cc b/base/synchronization/waitable_event_watcher_win.cc
index 46d47ac..43e3c47 100644
--- a/base/synchronization/waitable_event_watcher_win.cc
+++ b/base/synchronization/waitable_event_watcher_win.cc
@@ -10,23 +10,35 @@
 
 namespace base {
 
+WaitableEventWatcher::ObjectWatcherHelper::ObjectWatcherHelper(
+    WaitableEventWatcher* watcher)
+    : watcher_(watcher) {
+};
+
+void WaitableEventWatcher::ObjectWatcherHelper::OnObjectSignaled(HANDLE h) {
+  watcher_->OnObjectSignaled();
+}
+
+
 WaitableEventWatcher::WaitableEventWatcher()
-    : event_(NULL) {
+    : ALLOW_THIS_IN_INITIALIZER_LIST(helper_(this)),
+      event_(NULL),
+      delegate_(NULL) {
 }
 
 WaitableEventWatcher::~WaitableEventWatcher() {
 }
 
-bool WaitableEventWatcher::StartWatching(
-    WaitableEvent* event,
-    const EventCallback& callback) {
-  callback_ = callback;
+bool WaitableEventWatcher::StartWatching(WaitableEvent* event,
+                                         Delegate* delegate) {
+  delegate_ = delegate;
   event_ = event;
-  return watcher_.StartWatching(event->handle(), this);
+
+  return watcher_.StartWatching(event->handle(), &helper_);
 }
 
 void WaitableEventWatcher::StopWatching() {
-  callback_.Reset();
+  delegate_ = NULL;
   event_ = NULL;
   watcher_.StopWatching();
 }
@@ -35,14 +47,14 @@ WaitableEvent* WaitableEventWatcher::GetWatchedEvent() {
   return event_;
 }
 
-void WaitableEventWatcher::OnObjectSignaled(HANDLE h) {
+void WaitableEventWatcher::OnObjectSignaled() {
   WaitableEvent* event = event_;
-  EventCallback callback = callback_;
+  Delegate* delegate = delegate_;
   event_ = NULL;
-  callback_.Reset();
+  delegate_ = NULL;
   DCHECK(event);
 
-  callback.Run(event);
+  delegate->OnWaitableEventSignaled(event);
 }
 
 }  // namespace base
diff --git a/chrome/browser/browsing_data/browsing_data_remover.cc b/chrome/browser/browsing_data/browsing_data_remover.cc
index 120fd2c..932c138 100644
--- a/chrome/browser/browsing_data/browsing_data_remover.cc
+++ b/chrome/browser/browsing_data/browsing_data_remover.cc
@@ -418,11 +418,7 @@ void BrowsingDataRemover::RemoveImpl(int remove_mask,
       plugin_data_remover_.reset(content::PluginDataRemover::Create(profile_));
     base::WaitableEvent* event =
         plugin_data_remover_->StartRemoving(delete_begin_);
-
-    base::WaitableEventWatcher::EventCallback watcher_callback =
-        base::Bind(&BrowsingDataRemover::OnWaitableEventSignaled,
-                   base::Unretained(this));
-    watcher_.StartWatching(event, watcher_callback);
+    watcher_.StartWatching(event, this);
   }
 #endif
 
diff --git a/chrome/browser/browsing_data/browsing_data_remover.h b/chrome/browser/browsing_data/browsing_data_remover.h
index fbe13df..9cc02b0 100644
--- a/chrome/browser/browsing_data/browsing_data_remover.h
+++ b/chrome/browser/browsing_data/browsing_data_remover.h
@@ -50,11 +50,11 @@ struct SessionStorageUsageInfo;
 // BrowsingDataRemover is responsible for removing data related to browsing:
 // visits in url database, downloads, cookies ...
 
-class BrowsingDataRemover : public content::NotificationObserver
+class BrowsingDataRemover : public content::NotificationObserver,
 #if defined(ENABLE_PLUGINS)
-                            , public PepperFlashSettingsManager::Client
+                            public PepperFlashSettingsManager::Client,
 #endif
-                            {
+                            public base::WaitableEventWatcher::Delegate {
  public:
   // Time period ranges available when doing browsing data removals.
   enum TimePeriod {
@@ -210,8 +210,10 @@ class BrowsingDataRemover : public content::NotificationObserver
                        const content::NotificationSource& source,
                        const content::NotificationDetails& details) OVERRIDE;
 
+  // WaitableEventWatcher implementation.
   // Called when plug-in data has been cleared. Invokes NotifyAndDeleteIfDone.
-  void OnWaitableEventSignaled(base::WaitableEvent* waitable_event);
+  virtual void OnWaitableEventSignaled(
+      base::WaitableEvent* waitable_event) OVERRIDE;
 
 #if defined(ENABLE_PLUGINS)
   // PepperFlashSettingsManager::Client implementation.
diff --git a/content/browser/plugin_data_remover_impl_browsertest.cc b/content/browser/plugin_data_remover_impl_browsertest.cc
index 98b06d7..101987d 100644
--- a/content/browser/plugin_data_remover_impl_browsertest.cc
+++ b/content/browser/plugin_data_remover_impl_browsertest.cc
@@ -3,7 +3,6 @@
 // found in the LICENSE file.
 
 #include "base/base_paths.h"
-#include "base/callback.h"
 #include "base/command_line.h"
 #include "base/path_service.h"
 #include "base/synchronization/waitable_event_watcher.h"
@@ -20,11 +19,12 @@ namespace {
 const char* kNPAPITestPluginMimeType = "application/vnd.npapi-test";
 }
 
-class PluginDataRemoverTest : public ContentBrowserTest {
+class PluginDataRemoverTest : public ContentBrowserTest,
+                              public base::WaitableEventWatcher::Delegate {
  public:
   PluginDataRemoverTest() {}
 
-  void OnWaitableEventSignaled(base::WaitableEvent* waitable_event) {
+  virtual void OnWaitableEventSignaled(base::WaitableEvent* waitable_event) {
     MessageLoop::current()->Quit();
   }
 
@@ -51,9 +51,7 @@ IN_PROC_BROWSER_TEST_F(PluginDataRemoverTest, RemoveData) {
   base::WaitableEventWatcher watcher;
   base::WaitableEvent* event =
       plugin_data_remover.StartRemoving(base::Time());
-  watcher.StartWatching(
-      event,
-      base::Bind(&PluginDataRemoverTest::OnWaitableEventSignaled, this));
+  watcher.StartWatching(event, this);
   RunMessageLoop();
 }
 
diff --git a/content/browser/plugin_service_impl.cc b/content/browser/plugin_service_impl.cc
index e083774..9b90fe0 100644
--- a/content/browser/plugin_service_impl.cc
+++ b/content/browser/plugin_service_impl.cc
@@ -186,10 +186,7 @@ void PluginServiceImpl::StartWatchingPlugins() {
                        KEY_NOTIFY) == ERROR_SUCCESS) {
     if (hkcu_key_.StartWatching() == ERROR_SUCCESS) {
       hkcu_event_.reset(new base::WaitableEvent(hkcu_key_.watch_event()));
-      base::WaitableEventWatcher::EventCallback callback =
-            base::Bind(&PluginServiceImpl::OnWaitableEventSignaled,
-                       base::Unretained(this));
-      hkcu_watcher_.StartWatching(hkcu_event_.get(), callback);
+      hkcu_watcher_.StartWatching(hkcu_event_.get(), this);
     }
   }
   if (hklm_key_.Create(HKEY_LOCAL_MACHINE,
@@ -197,10 +194,7 @@ void PluginServiceImpl::StartWatchingPlugins() {
                        KEY_NOTIFY) == ERROR_SUCCESS) {
     if (hklm_key_.StartWatching() == ERROR_SUCCESS) {
       hklm_event_.reset(new base::WaitableEvent(hklm_key_.watch_event()));
-      base::WaitableEventWatcher::EventCallback callback =
-            base::Bind(&PluginServiceImpl::OnWaitableEventSignaled,
-                       base::Unretained(this));
-      hklm_watcher_.StartWatching(hklm_event_.get(), callback);
+      hklm_watcher_.StartWatching(hklm_event_.get(), this);
     }
   }
 #endif
diff --git a/content/browser/plugin_service_impl.h b/content/browser/plugin_service_impl.h
index 81ef427..8808c4b 100644
--- a/content/browser/plugin_service_impl.h
+++ b/content/browser/plugin_service_impl.h
@@ -64,7 +64,8 @@ struct PluginServiceFilterParams {
 };
 
 class CONTENT_EXPORT PluginServiceImpl
-    : NON_EXPORTED_BASE(public PluginService) {
+    : NON_EXPORTED_BASE(public PluginService),
+      public base::WaitableEventWatcher::Delegate {
  public:
   // Returns the PluginServiceImpl singleton.
   static PluginServiceImpl* GetInstance();
@@ -156,7 +157,9 @@ class CONTENT_EXPORT PluginServiceImpl
   PluginServiceImpl();
   virtual ~PluginServiceImpl();
 
-  void OnWaitableEventSignaled(base::WaitableEvent* waitable_event);
+  // base::WaitableEventWatcher::Delegate implementation.
+  virtual void OnWaitableEventSignaled(
+      base::WaitableEvent* waitable_event) OVERRIDE;
 
   // Returns the plugin process host corresponding to the plugin process that
   // has been started by this service. Returns NULL if no process has been
diff --git a/ipc/ipc_sync_channel.cc b/ipc/ipc_sync_channel.cc
index fef7c8c..a300c0f 100644
--- a/ipc/ipc_sync_channel.cc
+++ b/ipc/ipc_sync_channel.cc
@@ -234,8 +234,6 @@ SyncChannel::SyncContext::SyncContext(
       received_sync_msgs_(ReceivedSyncMsgQueue::AddContext()),
       shutdown_event_(shutdown_event),
       restrict_dispatch_group_(kRestrictDispatchGroup_None) {
-  shutdown_watcher_callback_ = base::Bind(
-     &SyncChannel::SyncContext::OnWaitableEventSignaled, this);
 }
 
 SyncChannel::SyncContext::~SyncContext() {
@@ -355,7 +353,7 @@ void SyncChannel::SyncContext::OnChannelError() {
 }
 
 void SyncChannel::SyncContext::OnChannelOpened() {
-  shutdown_watcher_.StartWatching(shutdown_event_, shutdown_watcher_callback_);
+  shutdown_watcher_.StartWatching(shutdown_event_, this);
   Context::OnChannelOpened();
 }
 
@@ -519,22 +517,21 @@ void SyncChannel::WaitForReplyWithNestedMessageLoop(SyncContext* context) {
   base::WaitableEventWatcher* old_send_done_event_watcher =
       sync_msg_queue->top_send_done_watcher();
 
-  base::WaitableEventWatcher::EventCallback old_callback;
+  base::WaitableEventWatcher::Delegate* old_delegate = NULL;
   base::WaitableEvent* old_event = NULL;
 
   // Maintain a local global stack of send done delegates to ensure that
   // nested sync calls complete in the correct sequence, i.e. the
   // outermost call completes first, etc.
   if (old_send_done_event_watcher) {
-    old_callback = old_send_done_event_watcher->callback();
+    old_delegate = old_send_done_event_watcher->delegate();
     old_event = old_send_done_event_watcher->GetWatchedEvent();
     old_send_done_event_watcher->StopWatching();
   }
 
   sync_msg_queue->set_top_send_done_watcher(&send_done_watcher);
 
-  send_done_watcher.StartWatching(context->GetSendDoneEvent(),
-                                  context->shutdown_watcher_callback());
+  send_done_watcher.StartWatching(context->GetSendDoneEvent(), context);
 
   {
     MessageLoop::ScopedNestableTaskAllower allow(MessageLoop::current());
@@ -543,7 +540,7 @@ void SyncChannel::WaitForReplyWithNestedMessageLoop(SyncContext* context) {
 
   sync_msg_queue->set_top_send_done_watcher(old_send_done_event_watcher);
   if (old_send_done_event_watcher && old_event) {
-    old_send_done_event_watcher->StartWatching(old_event, old_callback);
+    old_send_done_event_watcher->StartWatching(old_event, old_delegate);
   }
 }
 
@@ -552,7 +549,7 @@ void SyncChannel::OnWaitableEventSignaled(WaitableEvent* event) {
   // The call to DispatchMessages might delete this object, so reregister
   // the object watcher first.
   event->Reset();
-  dispatch_watcher_.StartWatching(event, dispatch_watcher_callback_);
+  dispatch_watcher_.StartWatching(event, this);
   sync_context()->DispatchMessages();
 }
 
@@ -563,11 +560,7 @@ void SyncChannel::StartWatching() {
   // stop or keep watching.  So we always watch it, and create the event as
   // manual reset since the object watcher might otherwise reset the event
   // when we're doing a WaitMany.
-  dispatch_watcher_callback_ =
-      base::Bind(&SyncChannel::OnWaitableEventSignaled,
-                  base::Unretained(this));
-  dispatch_watcher_.StartWatching(sync_context()->GetDispatchEvent(),
-                                  dispatch_watcher_callback_);
+  dispatch_watcher_.StartWatching(sync_context()->GetDispatchEvent(), this);
 }
 
 }  // namespace IPC
diff --git a/ipc/ipc_sync_channel.h b/ipc/ipc_sync_channel.h
index 7b34b72..87fc1f4 100644
--- a/ipc/ipc_sync_channel.h
+++ b/ipc/ipc_sync_channel.h
@@ -58,7 +58,8 @@ class SyncMessage;
 // is more than this object.  If the message loop goes away while this object
 // is running and it's used to send a message, then it will use the invalid
 // message loop pointer to proxy it to the ipc thread.
-class IPC_EXPORT SyncChannel : public ChannelProxy {
+class IPC_EXPORT SyncChannel : public ChannelProxy,
+                               public base::WaitableEventWatcher::Delegate {
  public:
   enum RestrictDispatchGroup {
     kRestrictDispatchGroup_None = 0,
@@ -114,7 +115,8 @@ class IPC_EXPORT SyncChannel : public ChannelProxy {
   // SyncContext holds the per object data for SyncChannel, so that SyncChannel
   // can be deleted while it's being used in a different thread.  See
   // ChannelProxy::Context for more information.
-  class SyncContext : public Context {
+  class SyncContext : public Context,
+                      public base::WaitableEventWatcher::Delegate {
    public:
     SyncContext(Listener* listener,
                 base::SingleThreadTaskRunner* ipc_task_runner,
@@ -148,10 +150,6 @@ class IPC_EXPORT SyncChannel : public ChannelProxy {
     void OnSendTimeout(int message_id);
 
     base::WaitableEvent* shutdown_event() { return shutdown_event_; }
-    base::WaitableEventWatcher::EventCallback
-        shutdown_watcher_callback() const {
-      return shutdown_watcher_callback_;
-    }
 
     ReceivedSyncMsgQueue* received_sync_msgs() {
       return received_sync_msgs_;
@@ -181,7 +179,8 @@ class IPC_EXPORT SyncChannel : public ChannelProxy {
     // Cancels all pending Send calls.
     void CancelPendingSends();
 
-    void OnWaitableEventSignaled(base::WaitableEvent* arg);
+    // WaitableEventWatcher::Delegate implementation.
+    virtual void OnWaitableEventSignaled(base::WaitableEvent* arg) OVERRIDE;
 
     typedef std::deque<PendingSyncMsg> PendingSyncMessageQueue;
     PendingSyncMessageQueue deserializers_;
@@ -191,12 +190,12 @@ class IPC_EXPORT SyncChannel : public ChannelProxy {
 
     base::WaitableEvent* shutdown_event_;
     base::WaitableEventWatcher shutdown_watcher_;
-    base::WaitableEventWatcher::EventCallback shutdown_watcher_callback_;
     int restrict_dispatch_group_;
   };
 
  private:
-  void OnWaitableEventSignaled(base::WaitableEvent* arg);
+  // WaitableEventWatcher::Delegate implementation.
+  virtual void OnWaitableEventSignaled(base::WaitableEvent* arg) OVERRIDE;
 
   SyncContext* sync_context() {
     return reinterpret_cast<SyncContext*>(context());
@@ -218,7 +217,6 @@ class IPC_EXPORT SyncChannel : public ChannelProxy {
 
   // Used to signal events between the IPC and listener threads.
   base::WaitableEventWatcher dispatch_watcher_;
-  base::Callback<void(base::WaitableEvent*)> dispatch_watcher_callback_;
 
   DISALLOW_COPY_AND_ASSIGN(SyncChannel);
 };