WaitableEvent is the replacement for Windows events. Previously in the code, a HANDLE from CreateEvent was used for signaling, both within a process and across processes.

WaitableEvent is the cross platform replacement for this. To convert:
  * HANDLE -> base::WaitableEvent*
  * ScopedHandle -> scoped_ptr<base::WaitableEvent>
  * CreateEvent -> new base::WaitableEvent
  * SetEvent -> base::WaitableEvent::Signal
  * ResetEvent -> base::WaitableEvent::Reset
  * ObjectWatcher -> base::WaitableEventWatcher
  * WaitForMultipleObjects -> static base::WaitableEvent::WaitMany

ObjectWatcher remains for Windows specific code. WaitableEventWatcher has an identical interface save,
  * It uses WaitableEvents, not HANDLEs
  * It returns void from StartWatching and StopWatcher, rather than errors. System internal errors are fatal to the address space

IMPORTANT: There are semantic differences between the different platforms. WaitableEvents on Windows are implemented on top of events. Windows events work across process and this is used mostly for modal dialog support. Windows events can be duplicated with DuplicateHandle.

On other platforms, WaitableEvent works only within a single process. In the future we shall have to replace the current uses of cross-process events with IPCs.

BEWARE: HANDLE, on Windows, is a void *. Since any pointer type coerces to void *, you can pass a WaitableEvent * where a HANDLE is expected without any build-time errors.

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


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

1 files changed, 33 insertions, 7 deletions

diff --git a/base/waitable_event_win.cc b/base/waitable_event_win.cc
index 257f145..001a5df 100644
--- a/base/waitable_event_win.cc
+++ b/base/waitable_event_win.cc
@@ -13,22 +13,27 @@
 namespace base {
 
 WaitableEvent::WaitableEvent(bool manual_reset, bool signaled)
-    : event_(CreateEvent(NULL, manual_reset, signaled, NULL)) {
+    : handle_(CreateEvent(NULL, manual_reset, signaled, NULL)) {
   // We're probably going to crash anyways if this is ever NULL, so we might as
   // well make our stack reports more informative by crashing here.
-  CHECK(event_);
+  CHECK(handle_);
+}
+
+WaitableEvent::WaitableEvent(HANDLE handle)
+    : handle_(handle) {
+  CHECK(handle) << "Tried to create WaitableEvent from NULL handle";
 }
 
 WaitableEvent::~WaitableEvent() {
-  CloseHandle(event_);
+  CloseHandle(handle_);
 }
 
 void WaitableEvent::Reset() {
-  ResetEvent(event_);
+  ResetEvent(handle_);
 }
 
 void WaitableEvent::Signal() {
-  SetEvent(event_);
+  SetEvent(handle_);
 }
 
 bool WaitableEvent::IsSignaled() {
@@ -36,7 +41,7 @@ bool WaitableEvent::IsSignaled() {
 }
 
 bool WaitableEvent::Wait() {
-  DWORD result = WaitForSingleObject(event_, INFINITE);
+  DWORD result = WaitForSingleObject(handle_, INFINITE);
   // It is most unexpected that this should ever fail.  Help consumers learn
   // about it if it should ever fail.
   DCHECK(result == WAIT_OBJECT_0) << "WaitForSingleObject failed";
@@ -49,7 +54,7 @@ bool WaitableEvent::TimedWait(const TimeDelta& max_time) {
   // is in milliseconds.  If there are 5.5ms left, should the delay be 5 or 6?
   // It should be 6 to avoid returning too early.
   double timeout = ceil(max_time.InMillisecondsF());
-  DWORD result = WaitForSingleObject(event_, static_cast<DWORD>(timeout));
+  DWORD result = WaitForSingleObject(handle_, static_cast<DWORD>(timeout));
   switch (result) {
     case WAIT_OBJECT_0:
       return true;
@@ -62,4 +67,25 @@ bool WaitableEvent::TimedWait(const TimeDelta& max_time) {
   return false;
 }
 
+// static
+size_t WaitableEvent::WaitMany(WaitableEvent** events, size_t count) {
+  HANDLE handles[MAXIMUM_WAIT_OBJECTS];
+  CHECK(count <= MAXIMUM_WAIT_OBJECTS)
+      << "Can only wait on " << MAXIMUM_WAIT_OBJECTS << " with WaitMany";
+
+  for (size_t i = 0; i < count; ++i)
+    handles[i] = events[i]->handle();
+
+  DWORD result =
+      WaitForMultipleObjects(count, handles,
+                             FALSE,      // don't wait for all the objects
+                             INFINITE);  // no timeout
+  if (result < WAIT_OBJECT_0 || result >= WAIT_OBJECT_0 + count) {
+    NOTREACHED() << "WaitForMultipleObjects failed: " << GetLastError();
+    return 0;
+  }
+
+  return result - WAIT_OBJECT_0;
+}
+
 }  // namespace base