summaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
Diffstat
-rw-r--r--base/synchronization/waitable_event_watcher.h92
-rw-r--r--base/synchronization/waitable_event_watcher_posix.cc25
-rw-r--r--base/synchronization/waitable_event_watcher_unittest.cc38
-rw-r--r--base/synchronization/waitable_event_watcher_win.cc34
-rw-r--r--chrome/browser/browsing_data/browsing_data_remover.cc6
-rw-r--r--chrome/browser/browsing_data/browsing_data_remover.h10
-rw-r--r--content/browser/plugin_data_remover_impl_browsertest.cc10
-rw-r--r--content/browser/plugin_service_impl.cc10
-rw-r--r--content/browser/plugin_service_impl.h7
-rw-r--r--ipc/ipc_sync_channel.cc21
-rw-r--r--ipc/ipc_sync_channel.h18
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);
};
generated by cgit v1.1 at 2025-02-12 10:24:17 +0000