Add CefWaitableEvent interface for unit tests (issue #1632)

BUILD.gn

@@ -475,6 +475,8 @@ static_library("libcef_static") {
     "libcef/common/value_base.h",
     "libcef/common/values_impl.cc",
     "libcef/common/values_impl.h",
+    "libcef/common/waitable_event_impl.cc",
+    "libcef/common/waitable_event_impl.h",
     "libcef/common/widevine_loader.cc",
     "libcef/common/widevine_loader.h",
     "libcef/renderer/browser_impl.cc",
@@ -1421,6 +1423,7 @@ cef_unittests_sources = [
   "tests/unittests/v8_unittest.cc",
   "tests/unittests/values_unittest.cc",
   "tests/unittests/version_unittest.cc",
+  "tests/unittests/waitable_event_unittest.cc",
   "tests/unittests/webui_unittest.cc",
   "tests/unittests/xml_reader_unittest.cc",
   "tests/unittests/zip_reader_unittest.cc",

cef_paths.gypi

@@ -71,6 +71,7 @@
       'include/cef_urlrequest.h',
       'include/cef_v8.h',
       'include/cef_values.h',
+      'include/cef_waitable_event.h',
       'include/cef_web_plugin.h',
       'include/cef_x509_certificate.h',
       'include/cef_xml_reader.h',
@@ -157,6 +158,7 @@
       'include/capi/cef_urlrequest_capi.h',
       'include/capi/cef_v8_capi.h',
       'include/capi/cef_values_capi.h',
+      'include/capi/cef_waitable_event_capi.h',
       'include/capi/cef_web_plugin_capi.h',
       'include/capi/cef_x509_certificate_capi.h',
       'include/capi/cef_xml_reader_capi.h',
@@ -422,6 +424,8 @@
       'libcef_dll/cpptoc/views/view_cpptoc.h',
       'libcef_dll/ctocpp/views/view_delegate_ctocpp.cc',
       'libcef_dll/ctocpp/views/view_delegate_ctocpp.h',
+      'libcef_dll/cpptoc/waitable_event_cpptoc.cc',
+      'libcef_dll/cpptoc/waitable_event_cpptoc.h',
       'libcef_dll/cpptoc/web_plugin_info_cpptoc.cc',
       'libcef_dll/cpptoc/web_plugin_info_cpptoc.h',
       'libcef_dll/ctocpp/web_plugin_info_visitor_ctocpp.cc',
@@ -682,6 +686,8 @@
       'libcef_dll/ctocpp/views/view_ctocpp.h',
       'libcef_dll/cpptoc/views/view_delegate_cpptoc.cc',
       'libcef_dll/cpptoc/views/view_delegate_cpptoc.h',
+      'libcef_dll/ctocpp/waitable_event_ctocpp.cc',
+      'libcef_dll/ctocpp/waitable_event_ctocpp.h',
       'libcef_dll/ctocpp/web_plugin_info_ctocpp.cc',
       'libcef_dll/ctocpp/web_plugin_info_ctocpp.h',
       'libcef_dll/cpptoc/web_plugin_info_visitor_cpptoc.cc',

include/capi/cef_waitable_event_capi.h

@@ -0,0 +1,117 @@
+// Copyright (c) 2016 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// This file was generated by the CEF translator tool and should not edited
+// by hand. See the translator.README.txt file in the tools directory for
+// more information.
+//
+
+#ifndef CEF_INCLUDE_CAPI_CEF_WAITABLE_EVENT_CAPI_H_
+#define CEF_INCLUDE_CAPI_CEF_WAITABLE_EVENT_CAPI_H_
+#pragma once
+
+#include "include/capi/cef_base_capi.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+///
+// WaitableEvent is a thread synchronization tool that allows one thread to wait
+// for another thread to finish some work. This is equivalent to using a
+// Lock+ConditionVariable to protect a simple boolean value. However, using
+// WaitableEvent in conjunction with a Lock to wait for a more complex state
+// change (e.g., for an item to be added to a queue) is not recommended. In that
+// case consider using a ConditionVariable instead of a WaitableEvent. It is
+// safe to create and/or signal a WaitableEvent from any thread. Blocking on a
+// WaitableEvent by calling the *wait() functions is not allowed on the browser
+// process UI or IO threads.
+///
+typedef struct _cef_waitable_event_t {
+  ///
+  // Base structure.
+  ///
+  cef_base_t base;
+
+  ///
+  // Put the event in the un-signaled state.
+  ///
+  void (CEF_CALLBACK *reset)(struct _cef_waitable_event_t* self);
+
+  ///
+  // Put the event in the signaled state. This causes any thread blocked on Wait
+  // to be woken up.
+  ///
+  void (CEF_CALLBACK *signal)(struct _cef_waitable_event_t* self);
+
+  ///
+  // Returns true (1) if the event is in the signaled state, else false (0). If
+  // the event was created with |automatic_reset| set to true (1) then calling
+  // this function will also cause a reset.
+  ///
+  int (CEF_CALLBACK *is_signaled)(struct _cef_waitable_event_t* self);
+
+  ///
+  // Wait indefinitely for the event to be signaled. This function will not
+  // return until after the call to signal() has completed. This function cannot
+  // be called on the browser process UI or IO threads.
+  ///
+  void (CEF_CALLBACK *wait)(struct _cef_waitable_event_t* self);
+
+  ///
+  // Wait up to |max_ms| milliseconds for the event to be signaled. Returns true
+  // (1) if the event was signaled. A return value of false (0) does not
+  // necessarily mean that |max_ms| was exceeded. This function will not return
+  // until after the call to signal() has completed. This function cannot be
+  // called on the browser process UI or IO threads.
+  ///
+  int (CEF_CALLBACK *timed_wait)(struct _cef_waitable_event_t* self,
+      int64 max_ms);
+} cef_waitable_event_t;
+
+
+///
+// Create a new waitable event. If |automatic_reset| is true (1) then the event
+// state is automatically reset to un-signaled after a single waiting thread has
+// been released; otherwise, the state remains signaled until reset() is called
+// manually. If |initially_signaled| is true (1) then the event will start in
+// the signaled state.
+///
+CEF_EXPORT cef_waitable_event_t* cef_waitable_event_create(int automatic_reset,
+    int initially_signaled);
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // CEF_INCLUDE_CAPI_CEF_WAITABLE_EVENT_CAPI_H_

include/cef_waitable_event.h

@@ -0,0 +1,109 @@
+// Copyright (c) 2016 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// The contents of this file must follow a specific format in order to
+// support the CEF translator tool. See the translator.README.txt file in the
+// tools directory for more information.
+//
+
+#ifndef CEF_INCLUDE_CEF_WAITABLE_EVENT_H_
+#define CEF_INCLUDE_CEF_WAITABLE_EVENT_H_
+#pragma once
+
+#include "include/cef_base.h"
+
+///
+// WaitableEvent is a thread synchronization tool that allows one thread to wait
+// for another thread to finish some work. This is equivalent to using a
+// Lock+ConditionVariable to protect a simple boolean value. However, using
+// WaitableEvent in conjunction with a Lock to wait for a more complex state
+// change (e.g., for an item to be added to a queue) is not recommended. In that
+// case consider using a ConditionVariable instead of a WaitableEvent. It is
+// safe to create and/or signal a WaitableEvent from any thread. Blocking on a
+// WaitableEvent by calling the *Wait() methods is not allowed on the browser
+// process UI or IO threads.
+///
+/*--cef(source=library)--*/
+class CefWaitableEvent : public CefBase {
+ public:
+  ///
+  // Create a new waitable event. If |automatic_reset| is true then the event
+  // state is automatically reset to un-signaled after a single waiting thread
+  // has been released; otherwise, the state remains signaled until Reset() is
+  // called manually. If |initially_signaled| is true then the event will start
+  // in the signaled state.
+  ///
+  /*--cef()--*/
+  static CefRefPtr<CefWaitableEvent> CreateWaitableEvent(
+      bool automatic_reset,
+      bool initially_signaled);
+
+  ///
+  // Put the event in the un-signaled state.
+  ///
+  /*--cef()--*/
+  virtual void Reset() =0;
+
+  ///
+  // Put the event in the signaled state. This causes any thread blocked on Wait
+  // to be woken up.
+  ///
+  /*--cef()--*/
+  virtual void Signal() =0;
+
+  ///
+  // Returns true if the event is in the signaled state, else false. If the
+  // event was created with |automatic_reset| set to true then calling this
+  // method will also cause a reset.
+  ///
+  /*--cef()--*/
+  virtual bool IsSignaled() =0;
+
+  ///
+  // Wait indefinitely for the event to be signaled. This method will not return
+  // until after the call to Signal() has completed. This method cannot be
+  // called on the browser process UI or IO threads.
+  ///
+  /*--cef()--*/
+  virtual void Wait() =0;
+
+  ///
+  // Wait up to |max_ms| milliseconds for the event to be signaled. Returns true
+  // if the event was signaled. A return value of false does not necessarily
+  // mean that |max_ms| was exceeded. This method will not return until after
+  // the call to Signal() has completed. This method cannot be called on the
+  // browser process UI or IO threads.
+  ///
+  /*--cef()--*/
+  virtual bool TimedWait(int64 max_ms) =0;
+};
+
+#endif  // CEF_INCLUDE_CEF_WAITABLE_EVENT_H_

libcef/common/waitable_event_impl.cc

@@ -0,0 +1,60 @@
+// Copyright 2016 The Chromium Embedded Framework 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 "libcef/common/waitable_event_impl.h"
+
+#include "include/cef_task.h"
+
+#include "base/time/time.h"
+
+namespace {
+
+bool AllowWait() {
+  if (CefCurrentlyOn(TID_UI) || CefCurrentlyOn(TID_IO)) {
+    NOTREACHED() << "waiting is not allowed on the current thread";
+    return false;
+  }
+  return true;
+}
+
+}  // namespace
+
+// static
+CefRefPtr<CefWaitableEvent> CefWaitableEvent::CreateWaitableEvent(
+    bool automatic_reset,
+    bool initially_signaled) {
+  return new CefWaitableEventImpl(automatic_reset, initially_signaled);
+}
+
+CefWaitableEventImpl::CefWaitableEventImpl(bool automatic_reset,
+                                           bool initially_signaled)
+  : event_(automatic_reset ? base::WaitableEvent::ResetPolicy::AUTOMATIC :
+                             base::WaitableEvent::ResetPolicy::MANUAL,
+           initially_signaled ? base::WaitableEvent::InitialState::SIGNALED :
+                              base::WaitableEvent::InitialState::NOT_SIGNALED) {
+}
+
+void CefWaitableEventImpl::Reset() {
+  event_.Reset();
+}
+
+void CefWaitableEventImpl::Signal() {
+  event_.Signal();
+}
+
+bool CefWaitableEventImpl::IsSignaled() {
+  return event_.IsSignaled();
+}
+
+void CefWaitableEventImpl::Wait() {
+  if (!AllowWait())
+    return;
+  event_.Wait();
+}
+
+bool CefWaitableEventImpl::TimedWait(int64 max_ms) {
+  if (!AllowWait())
+    return false;
+  return event_.TimedWait(base::TimeDelta::FromMilliseconds(max_ms));
+}

libcef/common/waitable_event_impl.h

@@ -0,0 +1,31 @@
+// Copyright 2016 The Chromium Embedded Framework Authors. All rights
+// reserved. Use of this source code is governed by a BSD-style license that can
+// be found in the LICENSE file.
+
+#ifndef  CEF_LIBCEF_COMMON_WAITABLE_EVENT_IMPL_H_
+#define  CEF_LIBCEF_COMMON_WAITABLE_EVENT_IMPL_H_
+#pragma once
+
+#include "include/cef_waitable_event.h"
+#include "base/synchronization/waitable_event.h"
+
+class CefWaitableEventImpl : public CefWaitableEvent {
+ public:
+  CefWaitableEventImpl(bool automatic_reset,
+                       bool initially_signaled);
+
+  // CefWaitableEvent methods:
+  void Reset() override;
+  void Signal() override;
+  bool IsSignaled() override;
+  void Wait() override;
+  bool TimedWait(int64 max_ms) override;
+
+ private:
+  base::WaitableEvent event_;
+
+  IMPLEMENT_REFCOUNTING(CefWaitableEventImpl);
+  DISALLOW_COPY_AND_ASSIGN(CefWaitableEventImpl);
+};
+
+#endif  // CEF_LIBCEF_COMMON_WAITABLE_EVENT_IMPL_H_

libcef_dll/cpptoc/waitable_event_cpptoc.cc

@@ -0,0 +1,126 @@
+// Copyright (c) 2016 The Chromium Embedded Framework Authors. All rights
+// reserved. Use of this source code is governed by a BSD-style license that
+// can be found in the LICENSE file.
+//
+// ---------------------------------------------------------------------------
+//
+// This file was generated by the CEF translator tool. If making changes by
+// hand only do so within the body of existing method and function
+// implementations. See the translator.README.txt file in the tools directory
+// for more information.
+//
+
+#include "libcef_dll/cpptoc/waitable_event_cpptoc.h"
+
+
+// GLOBAL FUNCTIONS - Body may be edited by hand.
+
+CEF_EXPORT cef_waitable_event_t* cef_waitable_event_create(int automatic_reset,
+    int initially_signaled) {
+  // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING
+
+  // Execute
+  CefRefPtr<CefWaitableEvent> _retval = CefWaitableEvent::CreateWaitableEvent(
+      automatic_reset?true:false,
+      initially_signaled?true:false);
+
+  // Return type: refptr_same
+  return CefWaitableEventCppToC::Wrap(_retval);
+}
+
+
+namespace {
+
+// MEMBER FUNCTIONS - Body may be edited by hand.
+
+void CEF_CALLBACK waitable_event_reset(struct _cef_waitable_event_t* self) {
+  // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING
+
+  DCHECK(self);
+  if (!self)
+    return;
+
+  // Execute
+  CefWaitableEventCppToC::Get(self)->Reset();
+}
+
+void CEF_CALLBACK waitable_event_signal(struct _cef_waitable_event_t* self) {
+  // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING
+
+  DCHECK(self);
+  if (!self)
+    return;
+
+  // Execute
+  CefWaitableEventCppToC::Get(self)->Signal();
+}
+
+int CEF_CALLBACK waitable_event_is_signaled(
+    struct _cef_waitable_event_t* self) {
+  // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING
+
+  DCHECK(self);
+  if (!self)
+    return 0;
+
+  // Execute
+  bool _retval = CefWaitableEventCppToC::Get(self)->IsSignaled();
+
+  // Return type: bool
+  return _retval;
+}
+
+void CEF_CALLBACK waitable_event_wait(struct _cef_waitable_event_t* self) {
+  // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING
+
+  DCHECK(self);
+  if (!self)
+    return;
+
+  // Execute
+  CefWaitableEventCppToC::Get(self)->Wait();
+}
+
+int CEF_CALLBACK waitable_event_timed_wait(struct _cef_waitable_event_t* self,
+    int64 max_ms) {
+  // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING
+
+  DCHECK(self);
+  if (!self)
+    return 0;
+
+  // Execute
+  bool _retval = CefWaitableEventCppToC::Get(self)->TimedWait(
+      max_ms);
+
+  // Return type: bool
+  return _retval;
+}
+
+}  // namespace
+
+
+// CONSTRUCTOR - Do not edit by hand.
+
+CefWaitableEventCppToC::CefWaitableEventCppToC() {
+  GetStruct()->reset = waitable_event_reset;
+  GetStruct()->signal = waitable_event_signal;
+  GetStruct()->is_signaled = waitable_event_is_signaled;
+  GetStruct()->wait = waitable_event_wait;
+  GetStruct()->timed_wait = waitable_event_timed_wait;
+}
+
+template<> CefRefPtr<CefWaitableEvent> CefCppToC<CefWaitableEventCppToC,
+    CefWaitableEvent, cef_waitable_event_t>::UnwrapDerived(CefWrapperType type,
+    cef_waitable_event_t* s) {
+  NOTREACHED() << "Unexpected class type: " << type;
+  return NULL;
+}
+
+#if DCHECK_IS_ON()
+template<> base::AtomicRefCount CefCppToC<CefWaitableEventCppToC,
+    CefWaitableEvent, cef_waitable_event_t>::DebugObjCt = 0;
+#endif
+
+template<> CefWrapperType CefCppToC<CefWaitableEventCppToC, CefWaitableEvent,
+    cef_waitable_event_t>::kWrapperType = WT_WAITABLE_EVENT;

libcef_dll/cpptoc/waitable_event_cpptoc.h

@@ -0,0 +1,35 @@
+// Copyright (c) 2016 The Chromium Embedded Framework Authors. All rights
+// reserved. Use of this source code is governed by a BSD-style license that
+// can be found in the LICENSE file.
+//
+// ---------------------------------------------------------------------------
+//
+// This file was generated by the CEF translator tool. If making changes by
+// hand only do so within the body of existing method and function
+// implementations. See the translator.README.txt file in the tools directory
+// for more information.
+//
+
+#ifndef CEF_LIBCEF_DLL_CPPTOC_WAITABLE_EVENT_CPPTOC_H_
+#define CEF_LIBCEF_DLL_CPPTOC_WAITABLE_EVENT_CPPTOC_H_
+#pragma once
+
+#ifndef BUILDING_CEF_SHARED
+#pragma message("Warning: "__FILE__" may be accessed DLL-side only")
+#else  // BUILDING_CEF_SHARED
+
+#include "include/cef_waitable_event.h"
+#include "include/capi/cef_waitable_event_capi.h"
+#include "libcef_dll/cpptoc/cpptoc.h"
+
+// Wrap a C++ class with a C structure.
+// This class may be instantiated and accessed DLL-side only.
+class CefWaitableEventCppToC
+    : public CefCppToC<CefWaitableEventCppToC, CefWaitableEvent,
+        cef_waitable_event_t> {
+ public:
+  CefWaitableEventCppToC();
+};
+
+#endif  // BUILDING_CEF_SHARED
+#endif  // CEF_LIBCEF_DLL_CPPTOC_WAITABLE_EVENT_CPPTOC_H_

libcef_dll/ctocpp/waitable_event_ctocpp.cc

@@ -0,0 +1,115 @@
+// Copyright (c) 2016 The Chromium Embedded Framework Authors. All rights
+// reserved. Use of this source code is governed by a BSD-style license that
+// can be found in the LICENSE file.
+//
+// ---------------------------------------------------------------------------
+//
+// This file was generated by the CEF translator tool. If making changes by
+// hand only do so within the body of existing method and function
+// implementations. See the translator.README.txt file in the tools directory
+// for more information.
+//
+
+#include "libcef_dll/ctocpp/waitable_event_ctocpp.h"
+
+
+// STATIC METHODS - Body may be edited by hand.
+
+CefRefPtr<CefWaitableEvent> CefWaitableEvent::CreateWaitableEvent(
+    bool automatic_reset, bool initially_signaled) {
+  // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING
+
+  // Execute
+  cef_waitable_event_t* _retval = cef_waitable_event_create(
+      automatic_reset,
+      initially_signaled);
+
+  // Return type: refptr_same
+  return CefWaitableEventCToCpp::Wrap(_retval);
+}
+
+
+// VIRTUAL METHODS - Body may be edited by hand.
+
+void CefWaitableEventCToCpp::Reset() {
+  cef_waitable_event_t* _struct = GetStruct();
+  if (CEF_MEMBER_MISSING(_struct, reset))
+    return;
+
+  // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING
+
+  // Execute
+  _struct->reset(_struct);
+}
+
+void CefWaitableEventCToCpp::Signal() {
+  cef_waitable_event_t* _struct = GetStruct();
+  if (CEF_MEMBER_MISSING(_struct, signal))
+    return;
+
+  // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING
+
+  // Execute
+  _struct->signal(_struct);
+}
+
+bool CefWaitableEventCToCpp::IsSignaled() {
+  cef_waitable_event_t* _struct = GetStruct();
+  if (CEF_MEMBER_MISSING(_struct, is_signaled))
+    return false;
+
+  // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING
+
+  // Execute
+  int _retval = _struct->is_signaled(_struct);
+
+  // Return type: bool
+  return _retval?true:false;
+}
+
+void CefWaitableEventCToCpp::Wait() {
+  cef_waitable_event_t* _struct = GetStruct();
+  if (CEF_MEMBER_MISSING(_struct, wait))
+    return;
+
+  // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING
+
+  // Execute
+  _struct->wait(_struct);
+}
+
+bool CefWaitableEventCToCpp::TimedWait(int64 max_ms) {
+  cef_waitable_event_t* _struct = GetStruct();
+  if (CEF_MEMBER_MISSING(_struct, timed_wait))
+    return false;
+
+  // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING
+
+  // Execute
+  int _retval = _struct->timed_wait(_struct,
+      max_ms);
+
+  // Return type: bool
+  return _retval?true:false;
+}
+
+
+// CONSTRUCTOR - Do not edit by hand.
+
+CefWaitableEventCToCpp::CefWaitableEventCToCpp() {
+}
+
+template<> cef_waitable_event_t* CefCToCpp<CefWaitableEventCToCpp,
+    CefWaitableEvent, cef_waitable_event_t>::UnwrapDerived(CefWrapperType type,
+    CefWaitableEvent* c) {
+  NOTREACHED() << "Unexpected class type: " << type;
+  return NULL;
+}
+
+#if DCHECK_IS_ON()
+template<> base::AtomicRefCount CefCToCpp<CefWaitableEventCToCpp,
+    CefWaitableEvent, cef_waitable_event_t>::DebugObjCt = 0;
+#endif
+
+template<> CefWrapperType CefCToCpp<CefWaitableEventCToCpp, CefWaitableEvent,
+    cef_waitable_event_t>::kWrapperType = WT_WAITABLE_EVENT;

libcef_dll/ctocpp/waitable_event_ctocpp.h

@@ -0,0 +1,42 @@
+// Copyright (c) 2016 The Chromium Embedded Framework Authors. All rights
+// reserved. Use of this source code is governed by a BSD-style license that
+// can be found in the LICENSE file.
+//
+// ---------------------------------------------------------------------------
+//
+// This file was generated by the CEF translator tool. If making changes by
+// hand only do so within the body of existing method and function
+// implementations. See the translator.README.txt file in the tools directory
+// for more information.
+//
+
+#ifndef CEF_LIBCEF_DLL_CTOCPP_WAITABLE_EVENT_CTOCPP_H_
+#define CEF_LIBCEF_DLL_CTOCPP_WAITABLE_EVENT_CTOCPP_H_
+#pragma once
+
+#ifndef USING_CEF_SHARED
+#pragma message("Warning: "__FILE__" may be accessed wrapper-side only")
+#else  // USING_CEF_SHARED
+
+#include "include/cef_waitable_event.h"
+#include "include/capi/cef_waitable_event_capi.h"
+#include "libcef_dll/ctocpp/ctocpp.h"
+
+// Wrap a C structure with a C++ class.
+// This class may be instantiated and accessed wrapper-side only.
+class CefWaitableEventCToCpp
+    : public CefCToCpp<CefWaitableEventCToCpp, CefWaitableEvent,
+        cef_waitable_event_t> {
+ public:
+  CefWaitableEventCToCpp();
+
+  // CefWaitableEvent methods.
+  void Reset() OVERRIDE;
+  void Signal() OVERRIDE;
+  bool IsSignaled() OVERRIDE;
+  void Wait() OVERRIDE;
+  bool TimedWait(int64 max_ms) OVERRIDE;
+};
+
+#endif  // USING_CEF_SHARED
+#endif  // CEF_LIBCEF_DLL_CTOCPP_WAITABLE_EVENT_CTOCPP_H_

libcef_dll/libcef_dll.cc

@@ -91,6 +91,7 @@
 #include "libcef_dll/cpptoc/v8value_cpptoc.h"
 #include "libcef_dll/cpptoc/value_cpptoc.h"
 #include "libcef_dll/cpptoc/views/view_cpptoc.h"
+#include "libcef_dll/cpptoc/waitable_event_cpptoc.h"
 #include "libcef_dll/cpptoc/web_plugin_info_cpptoc.h"
 #include "libcef_dll/cpptoc/views/window_cpptoc.h"
 #include "libcef_dll/cpptoc/x509cert_principal_cpptoc.h"
@@ -338,6 +339,7 @@ CEF_EXPORT void cef_shutdown() {
   DCHECK(base::AtomicRefCountIsZero(&CefValueCppToC::DebugObjCt));
   DCHECK(base::AtomicRefCountIsZero(&CefViewCppToC::DebugObjCt));
   DCHECK(base::AtomicRefCountIsZero(&CefViewDelegateCToCpp::DebugObjCt));
+  DCHECK(base::AtomicRefCountIsZero(&CefWaitableEventCppToC::DebugObjCt));
   DCHECK(base::AtomicRefCountIsZero(&CefWebPluginInfoCppToC::DebugObjCt));
   DCHECK(base::AtomicRefCountIsZero(
       &CefWebPluginInfoVisitorCToCpp::DebugObjCt));

libcef_dll/wrapper/libcef_dll_wrapper.cc

@@ -145,6 +145,7 @@
 #include "libcef_dll/ctocpp/v8value_ctocpp.h"
 #include "libcef_dll/ctocpp/value_ctocpp.h"
 #include "libcef_dll/ctocpp/views/view_ctocpp.h"
+#include "libcef_dll/ctocpp/waitable_event_ctocpp.h"
 #include "libcef_dll/ctocpp/web_plugin_info_ctocpp.h"
 #include "libcef_dll/ctocpp/views/window_ctocpp.h"
 #include "libcef_dll/ctocpp/x509cert_principal_ctocpp.h"
@@ -330,6 +331,7 @@ CEF_GLOBAL void CefShutdown() {
   DCHECK(base::AtomicRefCountIsZero(&CefValueCToCpp::DebugObjCt));
   DCHECK(base::AtomicRefCountIsZero(&CefViewCToCpp::DebugObjCt));
   DCHECK(base::AtomicRefCountIsZero(&CefViewDelegateCppToC::DebugObjCt));
+  DCHECK(base::AtomicRefCountIsZero(&CefWaitableEventCToCpp::DebugObjCt));
   DCHECK(base::AtomicRefCountIsZero(&CefWebPluginInfoCToCpp::DebugObjCt));
   DCHECK(base::AtomicRefCountIsZero(
       &CefWebPluginInfoVisitorCppToC::DebugObjCt));

libcef_dll/wrapper_types.h

@@ -135,6 +135,7 @@ enum CefWrapperType {
   WT_VALUE,
   WT_VIEW,
   WT_VIEW_DELEGATE,
+  WT_WAITABLE_EVENT,
   WT_WEB_PLUGIN_INFO,
   WT_WEB_PLUGIN_INFO_VISITOR,
   WT_WEB_PLUGIN_UNSTABLE_CALLBACK,

tests/unittests/cookie_unittest.cc

@@ -4,13 +4,12 @@
 
 #include <vector>
 
-#include "base/synchronization/waitable_event.h"
-
 #include "include/base/cef_bind.h"
 #include "include/base/cef_logging.h"
 #include "include/base/cef_ref_counted.h"
 #include "include/cef_cookie.h"
 #include "include/cef_scheme.h"
+#include "include/cef_waitable_event.h"
 #include "include/wrapper/cef_closure_task.h"
 #include "include/wrapper/cef_scoped_temp_dir.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ -31,7 +30,7 @@ typedef std::vector<CefCookie> CookieVector;
 
 class TestCompletionCallback : public CefCompletionCallback {
  public:
-  explicit TestCompletionCallback(base::WaitableEvent* event)
+  explicit TestCompletionCallback(CefRefPtr<CefWaitableEvent> event)
     : event_(event) {}
 
   void OnComplete() override {
@@ -39,7 +38,7 @@ class TestCompletionCallback : public CefCompletionCallback {
   }
 
  private:
-  base::WaitableEvent* event_;
+  CefRefPtr<CefWaitableEvent> event_;
 
   IMPLEMENT_REFCOUNTING(TestCompletionCallback);
   DISALLOW_COPY_AND_ASSIGN(TestCompletionCallback);
@@ -48,7 +47,7 @@ class TestCompletionCallback : public CefCompletionCallback {
 class TestSetCookieCallback : public CefSetCookieCallback {
  public:
   TestSetCookieCallback(bool expected_success,
-                       base::WaitableEvent* event)
+                       CefRefPtr<CefWaitableEvent> event)
     : expected_success_(expected_success),
       event_(event) {}
 
@@ -59,7 +58,7 @@ class TestSetCookieCallback : public CefSetCookieCallback {
 
  private:
   bool expected_success_;
-  base::WaitableEvent* event_;
+  CefRefPtr<CefWaitableEvent> event_;
 
   IMPLEMENT_REFCOUNTING(TestSetCookieCallback);
   DISALLOW_COPY_AND_ASSIGN(TestSetCookieCallback);
@@ -68,7 +67,7 @@ class TestSetCookieCallback : public CefSetCookieCallback {
 class TestDeleteCookiesCallback : public CefDeleteCookiesCallback {
  public:
   TestDeleteCookiesCallback(int expected_num_deleted,
-                            base::WaitableEvent* event)
+                            CefRefPtr<CefWaitableEvent> event)
     : expected_num_deleted_(expected_num_deleted),
       event_(event) {}
 
@@ -80,7 +79,7 @@ class TestDeleteCookiesCallback : public CefDeleteCookiesCallback {
 
  private:
   int expected_num_deleted_;
-  base::WaitableEvent* event_;
+  CefRefPtr<CefWaitableEvent> event_;
 
   IMPLEMENT_REFCOUNTING(TestDeleteCookiesCallback);
   DISALLOW_COPY_AND_ASSIGN(TestDeleteCookiesCallback);
@@ -89,7 +88,7 @@ class TestDeleteCookiesCallback : public CefDeleteCookiesCallback {
 class TestVisitor : public CefCookieVisitor {
  public:
   TestVisitor(CookieVector* cookies, bool deleteCookies,
-              base::WaitableEvent* event)
+              CefRefPtr<CefWaitableEvent> event)
     : cookies_(cookies),
       delete_cookies_(deleteCookies),
       event_(event) {
@@ -108,7 +107,7 @@ class TestVisitor : public CefCookieVisitor {
 
   CookieVector* cookies_;
   bool delete_cookies_;
-  base::WaitableEvent* event_;
+  CefRefPtr<CefWaitableEvent> event_;
 
   IMPLEMENT_REFCOUNTING(TestVisitor);
 };
@@ -117,12 +116,12 @@ class TestVisitor : public CefCookieVisitor {
 void SetCookies(CefRefPtr<CefCookieManager> manager,
                 const CefString& url, const CookieVector& cookies,
                 bool expected_success,
-                base::WaitableEvent& event) {
+                CefRefPtr<CefWaitableEvent> event) {
   CookieVector::const_iterator it = cookies.begin();
   for (; it != cookies.end(); ++it) {
     EXPECT_TRUE(manager->SetCookie(
-        url, *it, new TestSetCookieCallback(expected_success, &event)));
+        url, *it, new TestSetCookieCallback(expected_success, event)));
-    event.Wait();
+    event->Wait();
   }
 }
 
@@ -130,11 +129,11 @@ void SetCookies(CefRefPtr<CefCookieManager> manager,
 void DeleteCookies(CefRefPtr<CefCookieManager> manager,
                    const CefString& url, const CefString& cookie_name,
                    int expected_num_deleted,
-                   base::WaitableEvent& event) {
+                   CefRefPtr<CefWaitableEvent> event) {
   EXPECT_TRUE(manager->DeleteCookies(
       url, cookie_name,
-      new TestDeleteCookiesCallback(expected_num_deleted, &event)));
+      new TestDeleteCookiesCallback(expected_num_deleted, event)));
-  event.Wait();
+  event->Wait();
 }
 
 // Create a test cookie. If |withDomain| is true a domain cookie will be
@@ -142,7 +141,7 @@ void DeleteCookies(CefRefPtr<CefCookieManager> manager,
 void CreateCookie(CefRefPtr<CefCookieManager> manager,
                   CefCookie& cookie, bool withDomain,
                   bool sessionCookie,
-                  base::WaitableEvent& event) {
+                  CefRefPtr<CefWaitableEvent> event) {
   CefString(&cookie.name).FromASCII("my_cookie");
   CefString(&cookie.value).FromASCII("My Value");
   if (withDomain)
@@ -167,13 +166,13 @@ void CreateCookie(CefRefPtr<CefCookieManager> manager,
 // the cookie will be deleted when it's retrieved.
 void GetCookie(CefRefPtr<CefCookieManager> manager,
                const CefCookie& cookie, bool withDomain,
-               base::WaitableEvent& event, bool deleteCookies) {
+               CefRefPtr<CefWaitableEvent> event, bool deleteCookies) {
   CookieVector cookies;
 
   // Get the cookie and delete it.
   EXPECT_TRUE(manager->VisitUrlCookies(kTestUrl, false,
-      new TestVisitor(&cookies, deleteCookies, &event)));
+      new TestVisitor(&cookies, deleteCookies, event)));
-  event.Wait();
+  event->Wait();
 
   EXPECT_EQ(1U, cookies.size());
   if (cookies.size() != 1U)
@@ -204,49 +203,49 @@ void VisitUrlCookies(CefRefPtr<CefCookieManager> manager,
                      bool includeHttpOnly,
                      CookieVector& cookies,
                      bool deleteCookies,
-                     base::WaitableEvent& event) {
+                     CefRefPtr<CefWaitableEvent> event) {
   EXPECT_TRUE(manager->VisitUrlCookies(url, includeHttpOnly,
-      new TestVisitor(&cookies, deleteCookies, &event)));
+      new TestVisitor(&cookies, deleteCookies, event)));
-  event.Wait();
+  event->Wait();
 }
 
 // Visit all cookies.
 void VisitAllCookies(CefRefPtr<CefCookieManager> manager,
                      CookieVector& cookies,
                      bool deleteCookies,
-                     base::WaitableEvent& event) {
+                     CefRefPtr<CefWaitableEvent> event) {
   EXPECT_TRUE(manager->VisitAllCookies(
-      new TestVisitor(&cookies, deleteCookies, &event)));
+      new TestVisitor(&cookies, deleteCookies, event)));
-  event.Wait();
+  event->Wait();
 }
 
 // Verify that no cookies exist. If |withUrl| is true it will only check for
 // cookies matching the URL.
 void VerifyNoCookies(CefRefPtr<CefCookieManager> manager,
-                     base::WaitableEvent& event, bool withUrl) {
+                     CefRefPtr<CefWaitableEvent> event, bool withUrl) {
   CookieVector cookies;
 
   // Verify that the cookie has been deleted.
   if (withUrl) {
     EXPECT_TRUE(manager->VisitUrlCookies(kTestUrl, false,
-        new TestVisitor(&cookies, false, &event)));
+        new TestVisitor(&cookies, false, event)));
   } else {
     EXPECT_TRUE(manager->VisitAllCookies(
-        new TestVisitor(&cookies, false, &event)));
+        new TestVisitor(&cookies, false, event)));
   }
-  event.Wait();
+  event->Wait();
 
   EXPECT_EQ(0U, cookies.size());
 }
 
 // Delete all system cookies.
 void DeleteAllCookies(CefRefPtr<CefCookieManager> manager,
-                      base::WaitableEvent& event) {
+                      CefRefPtr<CefWaitableEvent> event) {
   DeleteCookies(manager, CefString(), CefString(), kIgnoreNumDeleted, event);
 }
 
 void TestDomainCookie(CefRefPtr<CefCookieManager> manager,
-                      base::WaitableEvent& event) {
+                      CefRefPtr<CefWaitableEvent> event) {
   CefCookie cookie;
 
   // Create a domain cookie.
@@ -260,7 +259,7 @@ void TestDomainCookie(CefRefPtr<CefCookieManager> manager,
 }
 
 void TestHostCookie(CefRefPtr<CefCookieManager> manager,
-                    base::WaitableEvent& event) {
+                    CefRefPtr<CefWaitableEvent> event) {
   CefCookie cookie;
 
   // Create a host cookie.
@@ -274,7 +273,7 @@ void TestHostCookie(CefRefPtr<CefCookieManager> manager,
 }
 
 void TestMultipleCookies(CefRefPtr<CefCookieManager> manager,
-                         base::WaitableEvent& event) {
+                         CefRefPtr<CefWaitableEvent> event) {
   std::stringstream ss;
   int i;
 
@@ -369,7 +368,7 @@ void TestMultipleCookies(CefRefPtr<CefCookieManager> manager,
 }
 
 void TestAllCookies(CefRefPtr<CefCookieManager> manager,
-                    base::WaitableEvent& event) {
+                    CefRefPtr<CefWaitableEvent> event) {
   CookieVector cookies;
 
   // Delete all system cookies just in case something is left over from a
@@ -446,7 +445,7 @@ void TestAllCookies(CefRefPtr<CefCookieManager> manager,
 }
 
 void TestChangeDirectory(CefRefPtr<CefCookieManager> manager,
-                         base::WaitableEvent& event,
+                         CefRefPtr<CefWaitableEvent> event,
                          const CefString& original_dir) {
   CefCookie cookie;
 
@@ -502,13 +501,12 @@ void TestChangeDirectory(CefRefPtr<CefCookieManager> manager,
 
 // Test creation of a domain cookie.
 TEST(CookieTest, DomainCookieGlobal) {
-  base::WaitableEvent event(
+  CefRefPtr<CefWaitableEvent> event =
-      base::WaitableEvent::ResetPolicy::AUTOMATIC,
+      CefWaitableEvent::CreateWaitableEvent(true, false);
-      base::WaitableEvent::InitialState::NOT_SIGNALED);
 
   CefRefPtr<CefCookieManager> manager =
-      CefCookieManager::GetGlobalManager(new TestCompletionCallback(&event));
+      CefCookieManager::GetGlobalManager(new TestCompletionCallback(event));
-  event.Wait();
+  event->Wait();
   EXPECT_TRUE(manager.get());
 
   TestDomainCookie(manager, event);
@@ -516,14 +514,13 @@ TEST(CookieTest, DomainCookieGlobal) {
 
 // Test creation of a domain cookie.
 TEST(CookieTest, DomainCookieInMemory) {
-  base::WaitableEvent event(
+  CefRefPtr<CefWaitableEvent> event =
-      base::WaitableEvent::ResetPolicy::AUTOMATIC,
+      CefWaitableEvent::CreateWaitableEvent(true, false);
-      base::WaitableEvent::InitialState::NOT_SIGNALED);
 
   CefRefPtr<CefCookieManager> manager =
       CefCookieManager::CreateManager(CefString(), false,
-                                      new TestCompletionCallback(&event));
+                                      new TestCompletionCallback(event));
-  event.Wait();
+  event->Wait();
   EXPECT_TRUE(manager.get());
 
   TestDomainCookie(manager, event);
@@ -536,14 +533,13 @@ TEST(CookieTest, DomainCookieOnDisk) {
   // Create a new temporary directory.
   EXPECT_TRUE(temp_dir.CreateUniqueTempDir());
 
-  base::WaitableEvent event(
+  CefRefPtr<CefWaitableEvent> event =
-      base::WaitableEvent::ResetPolicy::AUTOMATIC,
+      CefWaitableEvent::CreateWaitableEvent(true, false);
-      base::WaitableEvent::InitialState::NOT_SIGNALED);
 
   CefRefPtr<CefCookieManager> manager =
       CefCookieManager::CreateManager(temp_dir.GetPath(), false,
-                                      new TestCompletionCallback(&event));
+                                      new TestCompletionCallback(event));
-  event.Wait();
+  event->Wait();
   EXPECT_TRUE(manager.get());
 
   TestDomainCookie(manager, event);
@@ -556,13 +552,12 @@ TEST(CookieTest, DomainCookieOnDisk) {
 
 // Test creation of a host cookie.
 TEST(CookieTest, HostCookieGlobal) {
-  base::WaitableEvent event(
+  CefRefPtr<CefWaitableEvent> event =
-      base::WaitableEvent::ResetPolicy::AUTOMATIC,
+      CefWaitableEvent::CreateWaitableEvent(true, false);
-      base::WaitableEvent::InitialState::NOT_SIGNALED);
 
   CefRefPtr<CefCookieManager> manager =
-      CefCookieManager::GetGlobalManager(new TestCompletionCallback(&event));
+      CefCookieManager::GetGlobalManager(new TestCompletionCallback(event));
-  event.Wait();
+  event->Wait();
   EXPECT_TRUE(manager.get());
 
   TestHostCookie(manager, event);
@@ -570,14 +565,13 @@ TEST(CookieTest, HostCookieGlobal) {
 
 // Test creation of a host cookie.
 TEST(CookieTest, HostCookieInMemory) {
-  base::WaitableEvent event(
+  CefRefPtr<CefWaitableEvent> event =
-      base::WaitableEvent::ResetPolicy::AUTOMATIC,
+      CefWaitableEvent::CreateWaitableEvent(true, false);
-      base::WaitableEvent::InitialState::NOT_SIGNALED);
 
   CefRefPtr<CefCookieManager> manager =
       CefCookieManager::CreateManager(CefString(), false,
-                                      new TestCompletionCallback(&event));
+                                      new TestCompletionCallback(event));
-  event.Wait();
+  event->Wait();
   EXPECT_TRUE(manager.get());
 
   TestHostCookie(manager, event);
@@ -590,14 +584,13 @@ TEST(CookieTest, HostCookieOnDisk) {
   // Create a new temporary directory.
   EXPECT_TRUE(temp_dir.CreateUniqueTempDir());
 
-  base::WaitableEvent event(
+  CefRefPtr<CefWaitableEvent> event =
-      base::WaitableEvent::ResetPolicy::AUTOMATIC,
+      CefWaitableEvent::CreateWaitableEvent(true, false);
-      base::WaitableEvent::InitialState::NOT_SIGNALED);
 
   CefRefPtr<CefCookieManager> manager =
       CefCookieManager::CreateManager(temp_dir.GetPath(), false,
-                                      new TestCompletionCallback(&event));
+                                      new TestCompletionCallback(event));
-  event.Wait();
+  event->Wait();
   EXPECT_TRUE(manager.get());
 
   TestHostCookie(manager, event);
@@ -610,13 +603,12 @@ TEST(CookieTest, HostCookieOnDisk) {
 
 // Test creation of multiple cookies.
 TEST(CookieTest, MultipleCookiesGlobal) {
-  base::WaitableEvent event(
+  CefRefPtr<CefWaitableEvent> event =
-      base::WaitableEvent::ResetPolicy::AUTOMATIC,
+      CefWaitableEvent::CreateWaitableEvent(true, false);
-      base::WaitableEvent::InitialState::NOT_SIGNALED);
 
   CefRefPtr<CefCookieManager> manager =
-      CefCookieManager::GetGlobalManager(new TestCompletionCallback(&event));
+      CefCookieManager::GetGlobalManager(new TestCompletionCallback(event));
-  event.Wait();
+  event->Wait();
   EXPECT_TRUE(manager.get());
 
   TestMultipleCookies(manager, event);
@@ -624,14 +616,13 @@ TEST(CookieTest, MultipleCookiesGlobal) {
 
 // Test creation of multiple cookies.
 TEST(CookieTest, MultipleCookiesInMemory) {
-  base::WaitableEvent event(
+  CefRefPtr<CefWaitableEvent> event =
-      base::WaitableEvent::ResetPolicy::AUTOMATIC,
+      CefWaitableEvent::CreateWaitableEvent(true, false);
-      base::WaitableEvent::InitialState::NOT_SIGNALED);
 
   CefRefPtr<CefCookieManager> manager =
       CefCookieManager::CreateManager(CefString(), false,
-                                      new TestCompletionCallback(&event));
+                                      new TestCompletionCallback(event));
-  event.Wait();
+  event->Wait();
   EXPECT_TRUE(manager.get());
 
   TestMultipleCookies(manager, event);
@@ -644,14 +635,13 @@ TEST(CookieTest, MultipleCookiesOnDisk) {
   // Create a new temporary directory.
   EXPECT_TRUE(temp_dir.CreateUniqueTempDir());
 
-  base::WaitableEvent event(
+  CefRefPtr<CefWaitableEvent> event =
-      base::WaitableEvent::ResetPolicy::AUTOMATIC,
+      CefWaitableEvent::CreateWaitableEvent(true, false);
-      base::WaitableEvent::InitialState::NOT_SIGNALED);
 
   CefRefPtr<CefCookieManager> manager =
       CefCookieManager::CreateManager(temp_dir.GetPath(), false,
-                                      new TestCompletionCallback(&event));
+                                      new TestCompletionCallback(event));
-  event.Wait();
+  event->Wait();
   EXPECT_TRUE(manager.get());
 
   TestMultipleCookies(manager, event);
@@ -663,27 +653,25 @@ TEST(CookieTest, MultipleCookiesOnDisk) {
 }
 
 TEST(CookieTest, AllCookiesGlobal) {
-  base::WaitableEvent event(
+  CefRefPtr<CefWaitableEvent> event =
-      base::WaitableEvent::ResetPolicy::AUTOMATIC,
+      CefWaitableEvent::CreateWaitableEvent(true, false);
-      base::WaitableEvent::InitialState::NOT_SIGNALED);
 
   CefRefPtr<CefCookieManager> manager =
-      CefCookieManager::GetGlobalManager(new TestCompletionCallback(&event));
+      CefCookieManager::GetGlobalManager(new TestCompletionCallback(event));
-  event.Wait();
+  event->Wait();
   EXPECT_TRUE(manager.get());
 
   TestAllCookies(manager, event);
 }
 
 TEST(CookieTest, AllCookiesInMemory) {
-  base::WaitableEvent event(
+  CefRefPtr<CefWaitableEvent> event =
-      base::WaitableEvent::ResetPolicy::AUTOMATIC,
+      CefWaitableEvent::CreateWaitableEvent(true, false);
-      base::WaitableEvent::InitialState::NOT_SIGNALED);
 
   CefRefPtr<CefCookieManager> manager =
       CefCookieManager::CreateManager(CefString(), false,
-                                      new TestCompletionCallback(&event));
+                                      new TestCompletionCallback(event));
-  event.Wait();
+  event->Wait();
   EXPECT_TRUE(manager.get());
 
   TestAllCookies(manager, event);
@@ -695,14 +683,13 @@ TEST(CookieTest, AllCookiesOnDisk) {
   // Create a new temporary directory.
   EXPECT_TRUE(temp_dir.CreateUniqueTempDir());
 
-  base::WaitableEvent event(
+  CefRefPtr<CefWaitableEvent> event =
-      base::WaitableEvent::ResetPolicy::AUTOMATIC,
+      CefWaitableEvent::CreateWaitableEvent(true, false);
-      base::WaitableEvent::InitialState::NOT_SIGNALED);
 
   CefRefPtr<CefCookieManager> manager =
       CefCookieManager::CreateManager(temp_dir.GetPath(), false,
-                                      new TestCompletionCallback(&event));
+                                      new TestCompletionCallback(event));
-  event.Wait();
+  event->Wait();
   EXPECT_TRUE(manager.get());
 
   TestAllCookies(manager, event);
@@ -714,13 +701,12 @@ TEST(CookieTest, AllCookiesOnDisk) {
 }
 
 TEST(CookieTest, ChangeDirectoryGlobal) {
-  base::WaitableEvent event(
+  CefRefPtr<CefWaitableEvent> event =
-      base::WaitableEvent::ResetPolicy::AUTOMATIC,
+      CefWaitableEvent::CreateWaitableEvent(true, false);
-      base::WaitableEvent::InitialState::NOT_SIGNALED);
 
   CefRefPtr<CefCookieManager> manager =
-      CefCookieManager::GetGlobalManager(new TestCompletionCallback(&event));
+      CefCookieManager::GetGlobalManager(new TestCompletionCallback(event));
-  event.Wait();
+  event->Wait();
   EXPECT_TRUE(manager.get());
 
   std::string cache_path;
@@ -730,14 +716,13 @@ TEST(CookieTest, ChangeDirectoryGlobal) {
 }
 
 TEST(CookieTest, ChangeDirectoryCreated) {
-  base::WaitableEvent event(
+  CefRefPtr<CefWaitableEvent> event =
-      base::WaitableEvent::ResetPolicy::AUTOMATIC,
+      CefWaitableEvent::CreateWaitableEvent(true, false);
-      base::WaitableEvent::InitialState::NOT_SIGNALED);
 
   CefRefPtr<CefCookieManager> manager =
       CefCookieManager::CreateManager(CefString(), false,
-                                      new TestCompletionCallback(&event));
+                                      new TestCompletionCallback(event));
-  event.Wait();
+  event->Wait();
   EXPECT_TRUE(manager.get());
 
   TestChangeDirectory(manager, event, CefString());
@@ -745,9 +730,8 @@ TEST(CookieTest, ChangeDirectoryCreated) {
 
 TEST(CookieTest, SessionCookieNoPersist) {
   CefScopedTempDir temp_dir;
-  base::WaitableEvent event(
+  CefRefPtr<CefWaitableEvent> event =
-      base::WaitableEvent::ResetPolicy::AUTOMATIC,
+      CefWaitableEvent::CreateWaitableEvent(true, false);
-      base::WaitableEvent::InitialState::NOT_SIGNALED);
   CefCookie cookie;
 
   // Create a new temporary directory.
@@ -755,8 +739,8 @@ TEST(CookieTest, SessionCookieNoPersist) {
 
   CefRefPtr<CefCookieManager> manager =
       CefCookieManager::CreateManager(temp_dir.GetPath(), false,
-                                      new TestCompletionCallback(&event));
+                                      new TestCompletionCallback(event));
-  event.Wait();
+  event->Wait();
   EXPECT_TRUE(manager.get());
 
   // Create a session cookie.
@@ -766,13 +750,13 @@ TEST(CookieTest, SessionCookieNoPersist) {
   GetCookie(manager, cookie, true, event, false);
 
   // Flush the cookie store to disk.
-  manager->FlushStore(new TestCompletionCallback(&event));
+  manager->FlushStore(new TestCompletionCallback(event));
-  event.Wait();
+  event->Wait();
  
   // Create a new manager to read the same cookie store.
   manager = CefCookieManager::CreateManager(temp_dir.GetPath(), false,
-                                            new TestCompletionCallback(&event));
+                                            new TestCompletionCallback(event));
-  event.Wait();
+  event->Wait();
   EXPECT_TRUE(manager.get());
 
   // Verify that the cookie doesn't exist.
@@ -781,9 +765,8 @@ TEST(CookieTest, SessionCookieNoPersist) {
 
 TEST(CookieTest, SessionCookieWillPersist) {
   CefScopedTempDir temp_dir;
-  base::WaitableEvent event(
+  CefRefPtr<CefWaitableEvent> event =
-      base::WaitableEvent::ResetPolicy::AUTOMATIC,
+      CefWaitableEvent::CreateWaitableEvent(true, false);
-      base::WaitableEvent::InitialState::NOT_SIGNALED);
   CefCookie cookie;
 
   // Create a new temporary directory.
@@ -791,8 +774,8 @@ TEST(CookieTest, SessionCookieWillPersist) {
 
   CefRefPtr<CefCookieManager> manager =
       CefCookieManager::CreateManager(temp_dir.GetPath(), true,
-                                      new TestCompletionCallback(&event));
+                                      new TestCompletionCallback(event));
-  event.Wait();
+  event->Wait();
   EXPECT_TRUE(manager.get());
 
   // Create a session cookie.
@@ -802,13 +785,13 @@ TEST(CookieTest, SessionCookieWillPersist) {
   GetCookie(manager, cookie, true, event, false);
 
   // Flush the cookie store to disk.
-  manager->FlushStore(new TestCompletionCallback(&event));
+  manager->FlushStore(new TestCompletionCallback(event));
-  event.Wait();
+  event->Wait();
   
   // Create a new manager to read the same cookie store.
   manager = CefCookieManager::CreateManager(temp_dir.GetPath(), true,
-                                            new TestCompletionCallback(&event));
+                                            new TestCompletionCallback(event));
-  event.Wait();
+  event->Wait();
   EXPECT_TRUE(manager.get());
 
   // Verify that the cookie exists.
@@ -896,22 +879,40 @@ class CookieTestJSHandler : public TestHandler {
     SetTestTimeout();
   }
 
+  // Go to the next URL.
+  void LoadNextURL(CefRefPtr<CefFrame> frame) {
+    if (!CefCurrentlyOn(TID_UI)) {
+      CefPostTask(TID_UI,
+          base::Bind(&CookieTestJSHandler::LoadNextURL, this, frame));
+      return;
+    }
+
+    context_handler_->SetURL(kCookieJSUrl2);
+    frame->LoadURL(kCookieJSUrl2);
+  }
+
+  void CompleteTest() {
+    if (!CefCurrentlyOn(TID_UI)) {
+      CefPostTask(TID_UI,
+          base::Bind(&CookieTestJSHandler::CompleteTest, this));
+      return;
+    }
+
+    DestroyTest();
+  }
+
   void OnLoadEnd(CefRefPtr<CefBrowser> browser,
                  CefRefPtr<CefFrame> frame,
                  int httpStatusCode) override {
     std::string url = frame->GetURL();
     if (url == kCookieJSUrl1) {
       got_load_end1_.yes();
-      VerifyCookie(manager1_, url, "name1", "value1", got_cookie1_);
+      VerifyCookie(manager1_, url, "name1", "value1", &got_cookie1_,
-
+          base::Bind(&CookieTestJSHandler::LoadNextURL, this, frame));
-      // Go to the next URL
-      context_handler_->SetURL(kCookieJSUrl2);
-      frame->LoadURL(kCookieJSUrl2);
     } else {
       got_load_end2_.yes();
-      VerifyCookie(manager2_, url, "name2", "value2", got_cookie2_);
+      VerifyCookie(manager2_, url, "name2", "value2", &got_cookie2_,
-
+          base::Bind(&CookieTestJSHandler::CompleteTest, this));
-      DestroyTest();
     }
   }
 
@@ -927,10 +928,18 @@ class CookieTestJSHandler : public TestHandler {
                     const std::string& url,
                     const std::string& name,
                     const std::string& value,
-                    TrackCallback& callback) {
+                    TrackCallback* callback,
-    base::WaitableEvent event(
+                    const base::Closure& continue_callback) {
-        base::WaitableEvent::ResetPolicy::AUTOMATIC,
+    if (!CefCurrentlyOn(TID_FILE)) {
-        base::WaitableEvent::InitialState::NOT_SIGNALED);
+      CefPostTask(TID_FILE,
+          base::Bind(&CookieTestJSHandler::VerifyCookie, this, manager, url,
+                     name, value, base::Unretained(callback),
+                     continue_callback));
+      return;
+    }
+
+    CefRefPtr<CefWaitableEvent> event =
+        CefWaitableEvent::CreateWaitableEvent(true, false);
     CookieVector cookies;
 
     // Get the cookie.
@@ -938,8 +947,10 @@ class CookieTestJSHandler : public TestHandler {
 
     if (cookies.size() == 1U && CefString(&cookies[0].name) == name &&
         CefString(&cookies[0].value) == value) {
-      callback.yes();
+      callback->yes();
     }
+
+    continue_callback.Run();
   }
 
   CefRefPtr<RequestContextHandler> context_handler_;
@@ -1163,27 +1174,24 @@ class CookieTestSchemeHandler : public TestHandler {
     SetTestTimeout();
   }
 
-  void OnLoadEnd(CefRefPtr<CefBrowser> browser,
+  // Go to the next URL.
-                 CefRefPtr<CefFrame> frame,
+  void LoadNextURL(CefRefPtr<CefFrame> frame, const std::string& url) {
-                 int httpStatusCode) override {
+    if (!CefCurrentlyOn(TID_UI)) {
-    std::string url = frame->GetURL();
+      CefPostTask(TID_UI,
-    if (url == url1_) {
+          base::Bind(&CookieTestSchemeHandler::LoadNextURL, this, frame, url));
-      got_load_end1_.yes();
+      return;
-      VerifyCookie(manager1_, url, "name1", "value1", got_cookie1_);
+    }
 
-      // Go to the next URL
+    context_handler_->SetURL(url);
-      context_handler_->SetURL(url2_);
+    frame->LoadURL(url);
-      frame->LoadURL(url2_);
+  }
-    } else if (url == url2_) {
-      got_load_end2_.yes();
-      VerifyCookie(manager2_, url, "name2", "value2", got_cookie2_);
 
-      // Go to the next URL
+  void CompleteTest(CefRefPtr<CefBrowser> browser) {
-      context_handler_->SetURL(url3_);
+    if (!CefCurrentlyOn(TID_UI)) {
-      frame->LoadURL(url3_);
+      CefPostTask(TID_UI,
-    } else {
+          base::Bind(&CookieTestSchemeHandler::CompleteTest, this, browser));
-      got_load_end3_.yes();
+      return;
-      VerifyCookie(manager2_, url, "name2", "value2", got_cookie3_);
+    }
 
     // Unregister the scheme handler.
     browser->GetHost()->GetRequestContext()->RegisterSchemeHandlerFactory(
@@ -1191,6 +1199,26 @@ class CookieTestSchemeHandler : public TestHandler {
 
     DestroyTest();
   }
+
+  void OnLoadEnd(CefRefPtr<CefBrowser> browser,
+                 CefRefPtr<CefFrame> frame,
+                 int httpStatusCode) override {
+    std::string url = frame->GetURL();
+    if (url == url1_) {
+      got_load_end1_.yes();
+      VerifyCookie(manager1_, url, "name1", "value1", &got_cookie1_,
+          base::Bind(&CookieTestSchemeHandler::LoadNextURL, this, frame,
+                     url2_));
+    } else if (url == url2_) {
+      got_load_end2_.yes();
+      VerifyCookie(manager2_, url, "name2", "value2", &got_cookie2_,
+          base::Bind(&CookieTestSchemeHandler::LoadNextURL, this, frame,
+                     url3_));
+    } else {
+      got_load_end3_.yes();
+      VerifyCookie(manager2_, url, "name2", "value2", &got_cookie3_,
+          base::Bind(&CookieTestSchemeHandler::CompleteTest, this, browser));
+    }
   }
 
    void DestroyTest() override {
@@ -1205,10 +1233,18 @@ class CookieTestSchemeHandler : public TestHandler {
                     const std::string& url,
                     const std::string& name,
                     const std::string& value,
-                    TrackCallback& callback) {
+                    TrackCallback* callback,
-    base::WaitableEvent event(
+                    const base::Closure& continue_callback) {
-        base::WaitableEvent::ResetPolicy::AUTOMATIC,
+    if (!CefCurrentlyOn(TID_FILE)) {
-        base::WaitableEvent::InitialState::NOT_SIGNALED);
+      CefPostTask(TID_FILE,
+          base::Bind(&CookieTestSchemeHandler::VerifyCookie, this, manager, url,
+                     name, value, base::Unretained(callback),
+                     continue_callback));
+      return;
+    }
+
+    CefRefPtr<CefWaitableEvent> event =
+      CefWaitableEvent::CreateWaitableEvent(true, false);
     CookieVector cookies;
 
     // Get the cookie.
@@ -1216,8 +1252,10 @@ class CookieTestSchemeHandler : public TestHandler {
 
     if (cookies.size() == 1U && CefString(&cookies[0].name) == name &&
         CefString(&cookies[0].value) == value) {
-      callback.yes();
+      callback->yes();
     }
+
+    continue_callback.Run();
   }
 
   std::string scheme_;

tests/unittests/geolocation_unittest.cc

@@ -2,10 +2,9 @@
 // reserved. Use of this source code is governed by a BSD-style license that
 // can be found in the LICENSE file.
 
-#include "base/synchronization/waitable_event.h"
-
 #include "include/base/cef_bind.h"
 #include "include/cef_geolocation.h"
+#include "include/cef_waitable_event.h"
 #include "include/wrapper/cef_closure_task.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "tests/unittests/test_handler.h"
@@ -200,7 +199,7 @@ namespace {
 
 class TestGetGeolocationCallback : public CefGetGeolocationCallback {
  public:
-  explicit TestGetGeolocationCallback(base::WaitableEvent* event)
+  explicit TestGetGeolocationCallback(CefRefPtr<CefWaitableEvent> event)
       : event_(event) {
   }
 
@@ -219,7 +218,7 @@ class TestGetGeolocationCallback : public CefGetGeolocationCallback {
   }
 
 private:
-  base::WaitableEvent* event_;
+  CefRefPtr<CefWaitableEvent> event_;
 
   IMPLEMENT_REFCOUNTING(TestGetGeolocationCallback);
 };
@@ -227,9 +226,8 @@ private:
 }  // namespace
 
 TEST(GeolocationTest, GetGeolocation) {
-  base::WaitableEvent event(
+  CefRefPtr<CefWaitableEvent> event =
-      base::WaitableEvent::ResetPolicy::AUTOMATIC,
+      CefWaitableEvent::CreateWaitableEvent(true, false);
-      base::WaitableEvent::InitialState::NOT_SIGNALED);
+  CefGetGeolocation(new TestGetGeolocationCallback(event));
-  CefGetGeolocation(new TestGetGeolocationCallback(&event));
+  event->Wait();
-  event.Wait();
 }

tests/unittests/preference_unittest.cc

@@ -2,9 +2,8 @@
 // reserved. Use of this source code is governed by a BSD-style license that
 // can be found in the LICENSE file.
 
-#include "base/synchronization/waitable_event.h"
-
 #include "include/base/cef_bind.h"
+#include "include/cef_waitable_event.h"
 #include "include/wrapper/cef_closure_task.h"
 #include "tests/cefclient/browser/client_app_browser.h"
 #include "tests/unittests/test_handler.h"
@@ -243,7 +242,7 @@ void ValidateRoot(CefRefPtr<CefDictionaryValue> root,
 // Validate getting default values.
 void ValidateDefaults(CefRefPtr<CefRequestContext> context,
                       bool reset,
-                      base::WaitableEvent* event) {
+                      CefRefPtr<CefWaitableEvent> event) {
   if (!CefCurrentlyOn(TID_UI)) {
     CefPostTask(TID_UI, base::Bind(ValidateDefaults, context, reset, event));
     return;
@@ -317,7 +316,7 @@ void PopulateRootSet(CefRefPtr<CefDictionaryValue> val) {
 
 // Validate getting and setting values.
 void ValidateSetGet(CefRefPtr<CefRequestContext> context,
-                    base::WaitableEvent* event) {
+                    CefRefPtr<CefWaitableEvent> event) {
   if (!CefCurrentlyOn(TID_UI)) {
     CefPostTask(TID_UI, base::Bind(ValidateSetGet, context, event));
     return;
@@ -354,7 +353,7 @@ void ValidateSetGet(CefRefPtr<CefRequestContext> context,
 
 // Validate getting values.
 void ValidateGet(CefRefPtr<CefRequestContext> context,
-                 base::WaitableEvent* event) {
+                 CefRefPtr<CefWaitableEvent> event) {
   if (!CefCurrentlyOn(TID_UI)) {
     CefPostTask(TID_UI, base::Bind(ValidateGet, context, event));
     return;
@@ -402,39 +401,36 @@ class TestRequestContextHandler : public CefRequestContextHandler {
 
 // Verify default preference values on the global context.
 TEST(PreferenceTest, GlobalDefaults) {
-  base::WaitableEvent event(
+  CefRefPtr<CefWaitableEvent> event =
-      base::WaitableEvent::ResetPolicy::AUTOMATIC,
+      CefWaitableEvent::CreateWaitableEvent(true, false);
-      base::WaitableEvent::InitialState::NOT_SIGNALED);
 
   CefRefPtr<CefRequestContext> context = CefRequestContext::GetGlobalContext();
   EXPECT_TRUE(context.get());
 
-  ValidateDefaults(context, false, &event);
+  ValidateDefaults(context, false, event);
-  event.Wait();
+  event->Wait();
 }
 
 // Verify setting/getting preference values on the global context.
 TEST(PreferenceTest, GlobalSetGet) {
-  base::WaitableEvent event(
+  CefRefPtr<CefWaitableEvent> event =
-      base::WaitableEvent::ResetPolicy::AUTOMATIC,
+      CefWaitableEvent::CreateWaitableEvent(true, false);
-      base::WaitableEvent::InitialState::NOT_SIGNALED);
 
   CefRefPtr<CefRequestContext> context = CefRequestContext::GetGlobalContext();
   EXPECT_TRUE(context.get());
 
-  ValidateSetGet(context, &event);
+  ValidateSetGet(context, event);
-  event.Wait();
+  event->Wait();
 
   // Reset to the default values.
-  ValidateDefaults(context, true, &event);
+  ValidateDefaults(context, true, event);
-  event.Wait();
+  event->Wait();
 }
 
 // Verify setting/getting preference values on shared global contexts.
 TEST(PreferenceTest, GlobalSetGetShared) {
-  base::WaitableEvent event(
+  CefRefPtr<CefWaitableEvent> event =
-      base::WaitableEvent::ResetPolicy::AUTOMATIC,
+      CefWaitableEvent::CreateWaitableEvent(true, false);
-      base::WaitableEvent::InitialState::NOT_SIGNALED);
 
   CefRefPtr<CefRequestContext> context = CefRequestContext::GetGlobalContext();
   EXPECT_TRUE(context.get());
@@ -456,63 +452,60 @@ TEST(PreferenceTest, GlobalSetGetShared) {
   EXPECT_TRUE(context.get());
 
   // Set/get the values on the first context.
-  ValidateSetGet(context, &event);
+  ValidateSetGet(context, event);
-  event.Wait();
+  event->Wait();
 
   // Get the values from the 2nd and 3rd contexts. They should be the same.
-  ValidateGet(context2, &event);
+  ValidateGet(context2, event);
-  event.Wait();
+  event->Wait();
-  ValidateGet(context3, &event);
+  ValidateGet(context3, event);
-  event.Wait();
+  event->Wait();
 
   // Get the values from the 4th context. They should be at the default.
-  ValidateDefaults(context4, false, &event);
+  ValidateDefaults(context4, false, event);
-  event.Wait();
+  event->Wait();
 
   // Reset to the default values.
-  ValidateDefaults(context, true, &event);
+  ValidateDefaults(context, true, event);
-  event.Wait();
+  event->Wait();
 }
 
 // Verify default preference values on a custom context.
 TEST(PreferenceTest, CustomDefaults) {
-  base::WaitableEvent event(
+  CefRefPtr<CefWaitableEvent> event =
-      base::WaitableEvent::ResetPolicy::AUTOMATIC,
+      CefWaitableEvent::CreateWaitableEvent(true, false);
-      base::WaitableEvent::InitialState::NOT_SIGNALED);
 
   CefRequestContextSettings settings;
   CefRefPtr<CefRequestContext> context =
       CefRequestContext::CreateContext(settings, NULL);
   EXPECT_TRUE(context.get());
 
-  ValidateDefaults(context, false, &event);
+  ValidateDefaults(context, false, event);
-  event.Wait();
+  event->Wait();
 }
 
 // Verify setting/getting preference values on a custom context.
 TEST(PreferenceTest, CustomSetGet) {
-  base::WaitableEvent event(
+  CefRefPtr<CefWaitableEvent> event =
-      base::WaitableEvent::ResetPolicy::AUTOMATIC,
+      CefWaitableEvent::CreateWaitableEvent(true, false);
-      base::WaitableEvent::InitialState::NOT_SIGNALED);;
 
   CefRequestContextSettings settings;
   CefRefPtr<CefRequestContext> context =
       CefRequestContext::CreateContext(settings, NULL);
   EXPECT_TRUE(context.get());
 
-  ValidateSetGet(context, &event);
+  ValidateSetGet(context, event);
-  event.Wait();
+  event->Wait();
 
   // Reset to the default values.
-  ValidateDefaults(context, true, &event);
+  ValidateDefaults(context, true, event);
-  event.Wait();
+  event->Wait();
 }
 
 // Verify setting/getting preference values on shared custom contexts.
 TEST(PreferenceTest, CustomSetGetShared) {
-  base::WaitableEvent event(
+  CefRefPtr<CefWaitableEvent> event =
-      base::WaitableEvent::ResetPolicy::AUTOMATIC,
+      CefWaitableEvent::CreateWaitableEvent(true, false);
-      base::WaitableEvent::InitialState::NOT_SIGNALED);
 
   CefRequestContextSettings settings;
   CefRefPtr<CefRequestContext> context =
@@ -535,22 +528,22 @@ TEST(PreferenceTest, CustomSetGetShared) {
   EXPECT_TRUE(context.get());
 
   // Set/get the values on the first context.
-  ValidateSetGet(context, &event);
+  ValidateSetGet(context, event);
-  event.Wait();
+  event->Wait();
 
   // Get the values from the 2nd and 3d contexts. They should be the same.
-  ValidateGet(context2, &event);
+  ValidateGet(context2, event);
-  event.Wait();
+  event->Wait();
-  ValidateGet(context3, &event);
+  ValidateGet(context3, event);
-  event.Wait();
+  event->Wait();
 
   // Get the values from the 4th context. They should be at the default.
-  ValidateDefaults(context4, false, &event);
+  ValidateDefaults(context4, false, event);
-  event.Wait();
+  event->Wait();
 
   // Reset to the default values.
-  ValidateDefaults(context, true, &event);
+  ValidateDefaults(context, true, event);
-  event.Wait();
+  event->Wait();
 }
 
 

tests/unittests/task_unittest.cc

@@ -11,12 +11,12 @@
 namespace {
 
 void GetForCurrentThread(bool* ran_test) {
-  // Currently on the UI thread.
+  // Currently on the FILE thread.
   CefRefPtr<CefTaskRunner> runner = CefTaskRunner::GetForCurrentThread();
   EXPECT_TRUE(runner.get());
   EXPECT_TRUE(runner->BelongsToCurrentThread());
-  EXPECT_TRUE(runner->BelongsToThread(TID_UI));
+  EXPECT_TRUE(runner->BelongsToThread(TID_FILE));
-  EXPECT_FALSE(runner->BelongsToThread(TID_IO));
+  EXPECT_FALSE(runner->BelongsToThread(TID_DB));
   EXPECT_TRUE(runner->IsSame(runner));
 
   CefRefPtr<CefTaskRunner> runner2 = CefTaskRunner::GetForCurrentThread();
@@ -24,8 +24,8 @@ void GetForCurrentThread(bool* ran_test) {
   EXPECT_TRUE(runner->IsSame(runner2));
   EXPECT_TRUE(runner2->IsSame(runner));
 
-  // Not on the IO thread.
+  // Not on the DB thread.
-  CefRefPtr<CefTaskRunner> runner3 = CefTaskRunner::GetForThread(TID_IO);
+  CefRefPtr<CefTaskRunner> runner3 = CefTaskRunner::GetForThread(TID_DB);
   EXPECT_TRUE(runner3.get());
   EXPECT_FALSE(runner->IsSame(runner3));
   EXPECT_FALSE(runner3->IsSame(runner));
@@ -34,20 +34,20 @@ void GetForCurrentThread(bool* ran_test) {
 }
 
 void GetForThread(bool* ran_test) {
-  // Currently on the UI thread.
+  // Currently on the FILE thread.
-  CefRefPtr<CefTaskRunner> runner = CefTaskRunner::GetForThread(TID_IO);
+  CefRefPtr<CefTaskRunner> runner = CefTaskRunner::GetForThread(TID_DB);
   EXPECT_TRUE(runner.get());
   EXPECT_FALSE(runner->BelongsToCurrentThread());
-  EXPECT_TRUE(runner->BelongsToThread(TID_IO));
+  EXPECT_TRUE(runner->BelongsToThread(TID_DB));
-  EXPECT_FALSE(runner->BelongsToThread(TID_UI));
+  EXPECT_FALSE(runner->BelongsToThread(TID_FILE));
   EXPECT_TRUE(runner->IsSame(runner));
 
-  CefRefPtr<CefTaskRunner> runner2 = CefTaskRunner::GetForThread(TID_IO);
+  CefRefPtr<CefTaskRunner> runner2 = CefTaskRunner::GetForThread(TID_DB);
   EXPECT_TRUE(runner2.get());
   EXPECT_TRUE(runner->IsSame(runner2));
   EXPECT_TRUE(runner2->IsSame(runner));
 
-  CefRefPtr<CefTaskRunner> runner3 = CefTaskRunner::GetForThread(TID_UI);
+  CefRefPtr<CefTaskRunner> runner3 = CefTaskRunner::GetForThread(TID_FILE);
   EXPECT_TRUE(runner3.get());
   EXPECT_FALSE(runner->IsSame(runner3));
   EXPECT_FALSE(runner3->IsSame(runner));
@@ -56,35 +56,35 @@ void GetForThread(bool* ran_test) {
 }
 
 void PostTaskEvent1(bool* got_it, CefRefPtr<CefTaskRunner> runner) {
-  // Currently on the IO thread.
+  // Currently on the DB thread.
   EXPECT_TRUE(runner->BelongsToCurrentThread());
-  EXPECT_TRUE(runner->BelongsToThread(TID_IO));
+  EXPECT_TRUE(runner->BelongsToThread(TID_DB));
-  EXPECT_FALSE(runner->BelongsToThread(TID_UI));
+  EXPECT_FALSE(runner->BelongsToThread(TID_FILE));
 
-  // Current thread should be the IO thread.
+  // Current thread should be the DB thread.
   CefRefPtr<CefTaskRunner> runner2 = CefTaskRunner::GetForCurrentThread();
   EXPECT_TRUE(runner2.get());
   EXPECT_TRUE(runner2->BelongsToCurrentThread());
-  EXPECT_TRUE(runner2->BelongsToThread(TID_IO));
+  EXPECT_TRUE(runner2->BelongsToThread(TID_DB));
-  EXPECT_FALSE(runner2->BelongsToThread(TID_UI));
+  EXPECT_FALSE(runner2->BelongsToThread(TID_FILE));
   EXPECT_TRUE(runner->IsSame(runner2));
   EXPECT_TRUE(runner2->IsSame(runner));
 
-  // Current thread should be the IO thread.
+  // Current thread should be the DB thread.
-  CefRefPtr<CefTaskRunner> runner3 = CefTaskRunner::GetForThread(TID_IO);
+  CefRefPtr<CefTaskRunner> runner3 = CefTaskRunner::GetForThread(TID_DB);
   EXPECT_TRUE(runner3.get());
   EXPECT_TRUE(runner3->BelongsToCurrentThread());
-  EXPECT_TRUE(runner3->BelongsToThread(TID_IO));
+  EXPECT_TRUE(runner3->BelongsToThread(TID_DB));
-  EXPECT_FALSE(runner3->BelongsToThread(TID_UI));
+  EXPECT_FALSE(runner3->BelongsToThread(TID_FILE));
   EXPECT_TRUE(runner->IsSame(runner3));
   EXPECT_TRUE(runner3->IsSame(runner));
 
-  // Current thread should not be the UI thread.
+  // Current thread should not be the FILE thread.
-  CefRefPtr<CefTaskRunner> runner4 = CefTaskRunner::GetForThread(TID_UI);
+  CefRefPtr<CefTaskRunner> runner4 = CefTaskRunner::GetForThread(TID_FILE);
   EXPECT_TRUE(runner4.get());
   EXPECT_FALSE(runner4->BelongsToCurrentThread());
-  EXPECT_FALSE(runner4->BelongsToThread(TID_IO));
+  EXPECT_FALSE(runner4->BelongsToThread(TID_DB));
-  EXPECT_TRUE(runner4->BelongsToThread(TID_UI));
+  EXPECT_TRUE(runner4->BelongsToThread(TID_FILE));
   EXPECT_FALSE(runner->IsSame(runner4));
   EXPECT_FALSE(runner4->IsSame(runner));
 
@@ -92,11 +92,11 @@ void PostTaskEvent1(bool* got_it, CefRefPtr<CefTaskRunner> runner) {
 }
 
 void PostTask1(bool* ran_test) {
-  // Currently on the UI thread.
+  // Currently on the FILE thread.
-  CefRefPtr<CefTaskRunner> runner = CefTaskRunner::GetForThread(TID_IO);
+  CefRefPtr<CefTaskRunner> runner = CefTaskRunner::GetForThread(TID_DB);
   EXPECT_TRUE(runner.get());
   EXPECT_FALSE(runner->BelongsToCurrentThread());
-  EXPECT_TRUE(runner->BelongsToThread(TID_IO));
+  EXPECT_TRUE(runner->BelongsToThread(TID_DB));
   
   bool got_it = false;
   runner->PostTask(
@@ -109,11 +109,11 @@ void PostTask1(bool* ran_test) {
 }
 
 void PostDelayedTask1(bool* ran_test) {
-  // Currently on the UI thread.
+  // Currently on the FILE thread.
-  CefRefPtr<CefTaskRunner> runner = CefTaskRunner::GetForThread(TID_IO);
+  CefRefPtr<CefTaskRunner> runner = CefTaskRunner::GetForThread(TID_DB);
   EXPECT_TRUE(runner.get());
   EXPECT_FALSE(runner->BelongsToCurrentThread());
-  EXPECT_TRUE(runner->BelongsToThread(TID_IO));
+  EXPECT_TRUE(runner->BelongsToThread(TID_DB));
   
   bool got_it = false;
   runner->PostDelayedTask(
@@ -126,35 +126,35 @@ void PostDelayedTask1(bool* ran_test) {
 }
 
 void PostTaskEvent2(bool* got_it) {
-  EXPECT_TRUE(CefCurrentlyOn(TID_IO));
+  EXPECT_TRUE(CefCurrentlyOn(TID_DB));
-  EXPECT_FALSE(CefCurrentlyOn(TID_UI));
+  EXPECT_FALSE(CefCurrentlyOn(TID_FILE));
 
   *got_it = true;
 }
 
 void PostTask2(bool* ran_test) {
-  // Currently on the UI thread.
+  // Currently on the FILE thread.
-  EXPECT_FALSE(CefCurrentlyOn(TID_IO));
+  EXPECT_FALSE(CefCurrentlyOn(TID_DB));
 
   bool got_it = false;
-  CefPostTask(TID_IO,
+  CefPostTask(TID_DB,
       CefCreateClosureTask(base::Bind(&PostTaskEvent2, &got_it)));
 
-  WaitForThread(TID_IO);
+  WaitForThread(TID_DB);
   EXPECT_TRUE(got_it);
 
   *ran_test = true;
 }
 
 void PostDelayedTask2(bool* ran_test) {
-  // Currently on the UI thread.
+  // Currently on the FILE thread.
-  EXPECT_FALSE(CefCurrentlyOn(TID_IO));
+  EXPECT_FALSE(CefCurrentlyOn(TID_DB));
 
   bool got_it = false;
-  CefPostDelayedTask(TID_IO,
+  CefPostDelayedTask(TID_DB,
       CefCreateClosureTask(base::Bind(&PostTaskEvent2, &got_it)), 0);
 
-  WaitForThread(TID_IO);
+  WaitForThread(TID_DB);
   EXPECT_TRUE(got_it);
 
   *ran_test = true;
@@ -164,46 +164,46 @@ void PostDelayedTask2(bool* ran_test) {
 
 TEST(TaskTest, GetForCurrentThread) {
   bool ran_test = false;
-  CefPostTask(TID_UI,
+  CefPostTask(TID_FILE,
       CefCreateClosureTask(base::Bind(&GetForCurrentThread, &ran_test)));
-  WaitForThread(TID_UI);
+  WaitForThread(TID_FILE);
   EXPECT_TRUE(ran_test);
 }
 
 TEST(TaskTest, GetForThread) {
   bool ran_test = false;
-  CefPostTask(TID_UI,
+  CefPostTask(TID_FILE,
       CefCreateClosureTask(base::Bind(&GetForThread, &ran_test)));
-  WaitForThread(TID_UI);
+  WaitForThread(TID_FILE);
   EXPECT_TRUE(ran_test);
 }
 
 TEST(TaskTest, PostTask1) {
   bool ran_test = false;
-  CefPostTask(TID_UI, CefCreateClosureTask(base::Bind(&PostTask1, &ran_test)));
+  CefPostTask(TID_FILE, CefCreateClosureTask(base::Bind(&PostTask1, &ran_test)));
-  WaitForThread(TID_UI);
+  WaitForThread(TID_FILE);
   EXPECT_TRUE(ran_test);
 }
 
 TEST(TaskTest, PostDelayedTask1) {
   bool ran_test = false;
-  CefPostTask(TID_UI,
+  CefPostTask(TID_FILE,
       CefCreateClosureTask(base::Bind(&PostDelayedTask1, &ran_test)));
-  WaitForThread(TID_UI);
+  WaitForThread(TID_FILE);
   EXPECT_TRUE(ran_test);
 }
 
 TEST(TaskTest, PostTask2) {
   bool ran_test = false;
-  CefPostTask(TID_UI, CefCreateClosureTask(base::Bind(&PostTask2, &ran_test)));
+  CefPostTask(TID_FILE, CefCreateClosureTask(base::Bind(&PostTask2, &ran_test)));
-  WaitForThread(TID_UI);
+  WaitForThread(TID_FILE);
   EXPECT_TRUE(ran_test);
 }
 
 TEST(TaskTest, PostDelayedTask2) {
   bool ran_test = false;
-  CefPostTask(TID_UI,
+  CefPostTask(TID_FILE,
       CefCreateClosureTask(base::Bind(&PostDelayedTask2, &ran_test)));
-  WaitForThread(TID_UI);
+  WaitForThread(TID_FILE);
   EXPECT_TRUE(ran_test);
 }

tests/unittests/test_handler.cc

@@ -99,9 +99,8 @@ class TestBrowserViewDelegate : public CefBrowserViewDelegate {
 
 TestHandler::CompletionState::CompletionState(int total)
     : total_(total),
-      count_(0),
+      count_(0) {
-      event_(base::WaitableEvent::ResetPolicy::AUTOMATIC,
+  event_ = CefWaitableEvent::CreateWaitableEvent(true, false);
-             base::WaitableEvent::InitialState::NOT_SIGNALED) {
 }
 
 void TestHandler::CompletionState::TestComplete() {
@@ -110,16 +109,16 @@ void TestHandler::CompletionState::TestComplete() {
 
     // Signal that the test is now complete. Do not access any object members
     // after this call because |this| might be deleted.
-    event_.Signal();
+    event_->Signal();
   }
 }
 
 void TestHandler::CompletionState::WaitForTests() {
   // Wait for the test to complete
-  event_.Wait();
+  event_->Wait();
 
   // Reset the event so the same test can be executed again.
-  event_.Reset();
+  event_->Reset();
 }
 
 

tests/unittests/test_handler.h

@@ -16,9 +16,9 @@
 #include "include/cef_client.h"
 #include "include/cef_frame.h"
 #include "include/cef_task.h"
+#include "include/cef_waitable_event.h"
 #include "tests/unittests/thread_helper.h"
 
-#include "base/synchronization/waitable_event.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 class TrackCallback {
@@ -90,7 +90,7 @@ class TestHandler : public CefClient,
     int count_;
 
     // Handle used to notify when the test is complete
-    base::WaitableEvent event_;
+    CefRefPtr<CefWaitableEvent> event_;
   };
 
   // Represents a collection of related tests that need to be run
@@ -221,7 +221,9 @@ class TestHandler : public CefClient,
 
   // Event that will be signaled from the TestHandler destructor.
   // Used by ReleaseAndWaitForDestructor.
-  void SetDestroyEvent(base::WaitableEvent* event) { destroy_event_ = event; }
+  void SetDestroyEvent(CefRefPtr<CefWaitableEvent> event) {
+    destroy_event_ = event;
+  }
 
   // If a test will not call DestroyTest() indicate so using this method.
   void SetDestroyTestExpected(bool expected) {
@@ -310,7 +312,7 @@ class TestHandler : public CefClient,
   // If true test completion will be signaled when all browsers have closed.
   bool signal_completion_when_all_browsers_close_;
 
-  base::WaitableEvent* destroy_event_;
+  CefRefPtr<CefWaitableEvent> destroy_event_;
 
   // Tracks whether DestroyTest() is expected or has been called.
   bool destroy_test_expected_;
@@ -330,14 +332,12 @@ class TestHandler : public CefClient,
 // all Handler references have been released on test completion.
 template<typename T>
 void ReleaseAndWaitForDestructor(CefRefPtr<T>& handler, int delay_ms = 2000) {
-  base::WaitableEvent event(
+  CefRefPtr<CefWaitableEvent> event =
-      base::WaitableEvent::ResetPolicy::AUTOMATIC,
+      CefWaitableEvent::CreateWaitableEvent(true, false);
-      base::WaitableEvent::InitialState::NOT_SIGNALED);
+  handler->SetDestroyEvent(event);
-  handler->SetDestroyEvent(&event);
   T* _handler_ptr = handler.get();
   handler = NULL;
-  bool handler_destructed =
+  bool handler_destructed = event->TimedWait(delay_ms);
-      event.TimedWait(base::TimeDelta::FromMilliseconds(delay_ms));
   EXPECT_TRUE(handler_destructed);
   if (!handler_destructed) {
    // |event| is a stack variable so clear the reference before returning.

tests/unittests/thread_helper.cc

@@ -6,30 +6,28 @@
 
 #include "include/wrapper/cef_closure_task.h"
 
-void SignalEvent(base::WaitableEvent* event) {
+void SignalEvent(CefRefPtr<CefWaitableEvent> event) {
   event->Signal();
 }
 
 void WaitForThread(CefThreadId thread_id, int64 delay_ms) {
-  base::WaitableEvent event(
+  CefRefPtr<CefWaitableEvent> event =
-      base::WaitableEvent::ResetPolicy::AUTOMATIC,
+      CefWaitableEvent::CreateWaitableEvent(true, false);
-      base::WaitableEvent::InitialState::NOT_SIGNALED);
+  CefPostDelayedTask(thread_id, base::Bind(SignalEvent, event), delay_ms);
-  CefPostDelayedTask(thread_id, base::Bind(SignalEvent, &event), delay_ms);
+  event->Wait();
-  event.Wait();
 }
 
 void WaitForThread(CefRefPtr<CefTaskRunner> task_runner, int64 delay_ms) {
-  base::WaitableEvent event(
+  CefRefPtr<CefWaitableEvent> event =
-      base::WaitableEvent::ResetPolicy::AUTOMATIC,
+      CefWaitableEvent::CreateWaitableEvent(true, false);
-      base::WaitableEvent::InitialState::NOT_SIGNALED);
   task_runner->PostDelayedTask(
-      CefCreateClosureTask(base::Bind(SignalEvent, &event)), delay_ms);
+      CefCreateClosureTask(base::Bind(SignalEvent, event)), delay_ms);
-  event.Wait();
+  event->Wait();
 }
 
 void RunOnThread(CefThreadId thread_id,
                  const base::Callback<void(void)>& test_impl,
-                 base::WaitableEvent* event) {
+                 CefRefPtr<CefWaitableEvent> event) {
   if (!CefCurrentlyOn(thread_id)) {
     CefPostTask(thread_id,
         base::Bind(RunOnThread, thread_id, test_impl, event));
@@ -42,8 +40,8 @@ void RunOnThread(CefThreadId thread_id,
 
 void RunOnThreadAsync(
     CefThreadId thread_id,
-    const base::Callback<void(base::WaitableEvent*)>& test_impl,
+    const base::Callback<void(CefRefPtr<CefWaitableEvent>)>& test_impl,
-    base::WaitableEvent* event) {
+    CefRefPtr<CefWaitableEvent> event) {
   if (!CefCurrentlyOn(thread_id)) {
     CefPostTask(thread_id,
         base::Bind(RunOnThreadAsync, thread_id, test_impl, event));

tests/unittests/thread_helper.h

@@ -8,11 +8,10 @@
 
 #include "include/base/cef_bind.h"
 #include "include/cef_task.h"
-
+#include "include/cef_waitable_event.h"
-#include "base/synchronization/waitable_event.h"
 
 // Helper for signaling |event|.
-void SignalEvent(base::WaitableEvent* event);
+void SignalEvent(CefRefPtr<CefWaitableEvent> event);
 
 // Post a task to the specified thread and wait for the task to execute as
 // indication that all previously pending tasks on that thread have completed.
@@ -36,15 +35,14 @@ void WaitForThread(CefRefPtr<CefTaskRunner> task_runner, int64 delay_ms = 0);
 // once execution is complete.
 void RunOnThread(CefThreadId thread_id,
                  const base::Callback<void(void)>& test_impl,
-                 base::WaitableEvent* event);
+                 CefRefPtr<CefWaitableEvent> event);
 
 #define NAMED_THREAD_TEST(thread_id, test_case_name, test_name)  \
     TEST(test_case_name, test_name) { \
-      base::WaitableEvent event( \
+      CefRefPtr<CefWaitableEvent> event = \
-          base::WaitableEvent::ResetPolicy::AUTOMATIC, \
+          CefWaitableEvent::CreateWaitableEvent(true, false); \
-          base::WaitableEvent::InitialState::NOT_SIGNALED); \
+      RunOnThread(thread_id, base::Bind(test_name##Impl), event); \
-      RunOnThread(thread_id, base::Bind(test_name##Impl), &event); \
+      event->Wait(); \
-      event.Wait(); \
     }
 
 // Execute "test_case_name.test_name" test on the named thread. The test
@@ -55,20 +53,19 @@ void RunOnThread(CefThreadId thread_id,
 // Like RunOnThread() but |test_impl| is responsible for signaling |event|.
 void RunOnThreadAsync(
     CefThreadId thread_id,
-    const base::Callback<void(base::WaitableEvent*)>& test_impl,
+    const base::Callback<void(CefRefPtr<CefWaitableEvent>)>& test_impl,
-    base::WaitableEvent* event);
+    CefRefPtr<CefWaitableEvent>);
 
 #define NAMED_THREAD_TEST_ASYNC(thread_id, test_case_name, test_name)  \
     TEST(test_case_name, test_name) { \
-      base::WaitableEvent event( \
+      CefRefPtr<CefWaitableEvent> event = \
-          base::WaitableEvent::ResetPolicy::AUTOMATIC, \
+          CefWaitableEvent::CreateWaitableEvent(true, false); \
-          base::WaitableEvent::InitialState::NOT_SIGNALED); \
+      RunOnThreadAsync(thread_id, base::Bind(test_name##Impl), event); \
-      RunOnThreadAsync(thread_id, base::Bind(test_name##Impl), &event); \
+      event->Wait(); \
-      event.Wait(); \
     }
 
 // Execute "test_case_name.test_name" test on the named thread. The test
-// implementation is "void test_nameImpl(base::WaitableEvent* event)".
+// implementation is "void test_nameImpl(CefRefPtr<CefWaitableEvent> event)".
 #define UI_THREAD_TEST_ASYNC(test_case_name, test_name)  \
     NAMED_THREAD_TEST_ASYNC(TID_UI, test_case_name, test_name)
 

tests/unittests/tracing_unittest.cc

@@ -2,12 +2,11 @@
 // reserved. Use of this source code is governed by a BSD-style license that
 // can be found in the LICENSE file.
 
-#include "base/synchronization/waitable_event.h"
-
 #include "include/base/cef_bind.h"
 #include "include/cef_file_util.h"
 #include "include/cef_task.h"
 #include "include/cef_trace.h"
+#include "include/cef_waitable_event.h"
 #include "include/wrapper/cef_closure_task.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "tests/unittests/file_util.h"
@@ -75,10 +74,9 @@ class TracingTestHandler : public CefEndTracingCallback,
                            public CefCompletionCallback {
  public:
   TracingTestHandler(TracingTestType type, const char* trace_type)
-      : completion_event_(base::WaitableEvent::ResetPolicy::AUTOMATIC,
+      : trace_type_(trace_type),
-                          base::WaitableEvent::InitialState::NOT_SIGNALED),
-        trace_type_(trace_type),
         type_(type) {
+    completion_event_ = CefWaitableEvent::CreateWaitableEvent(true, false);
   }
 
   void ReadTracingFile(const std::string& file_path) {
@@ -87,7 +85,7 @@ class TracingTestHandler : public CefEndTracingCallback,
     EXPECT_TRUE(file_util::ReadFileToString(file_path, &trace_data_));
     EXPECT_TRUE(CefDeleteFile(file_path, false));
 
-    completion_event_.Signal();
+    completion_event_->Signal();
   }
 
   // CefEndTracingCallback method:
@@ -328,7 +326,7 @@ class TracingTestHandler : public CefEndTracingCallback,
     CefPostTask(TID_UI, base::Bind(&TracingTestHandler::RunTracing, this));
 
     // Wait for the test to complete.
-    completion_event_.Wait();
+    completion_event_->Wait();
 
     // Verify the results.
     EXPECT_TRUE(!trace_data_.empty());
@@ -340,7 +338,7 @@ class TracingTestHandler : public CefEndTracingCallback,
   ~TracingTestHandler() override {}
 
   // Handle used to notify when the test is complete.
-  base::WaitableEvent completion_event_;
+  CefRefPtr<CefWaitableEvent> completion_event_;
 
   const char* trace_type_;
   TracingTestType type_;

tests/unittests/urlrequest_unittest.cc

@@ -5,12 +5,11 @@
 #include <map>
 #include <sstream>
 
-#include "base/synchronization/waitable_event.h"
-
 #include "include/base/cef_bind.h"
 #include "include/cef_scheme.h"
 #include "include/cef_task.h"
 #include "include/cef_urlrequest.h"
+#include "include/cef_waitable_event.h"
 #include "include/wrapper/cef_closure_task.h"
 #include "include/wrapper/cef_scoped_temp_dir.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ -149,7 +148,7 @@ void SetTestCookie(CefRefPtr<CefRequestContext> request_context) {
 
   class Callback : public CefSetCookieCallback {
    public:
-    explicit Callback(base::WaitableEvent* event)
+    explicit Callback(CefRefPtr<CefWaitableEvent> event)
       : event_(event) {
       EXPECT_TRUE(event_);
     }
@@ -161,14 +160,13 @@ void SetTestCookie(CefRefPtr<CefRequestContext> request_context) {
     }
 
    private:
-    base::WaitableEvent* event_;
+    CefRefPtr<CefWaitableEvent> event_;
 
     IMPLEMENT_REFCOUNTING(Callback);
   };
 
-  base::WaitableEvent event(
+  CefRefPtr<CefWaitableEvent> event =
-      base::WaitableEvent::ResetPolicy::MANUAL,
+      CefWaitableEvent::CreateWaitableEvent(false, false);
-      base::WaitableEvent::InitialState::NOT_SIGNALED);
 
   CefCookie cookie;
   CefString(&cookie.name) = kRequestSendCookieName;
@@ -177,11 +175,11 @@ void SetTestCookie(CefRefPtr<CefRequestContext> request_context) {
   CefString(&cookie.path) = "/";
   cookie.has_expires = false;
   EXPECT_TRUE(request_context->GetDefaultCookieManager(NULL)->SetCookie(
-      kRequestOrigin, cookie, new Callback(&event)));
+      kRequestOrigin, cookie, new Callback(event)));
 
   // Wait for the Callback.
-  event.TimedWait(base::TimeDelta::FromSeconds(2));
+  event->TimedWait(2000);
-  EXPECT_TRUE(event.IsSignaled());
+  EXPECT_TRUE(event->IsSignaled());
 }
 
 // Tests if the save cookie has been set. If set, it will be deleted at the same
@@ -192,7 +190,7 @@ void GetTestCookie(CefRefPtr<CefRequestContext> request_context,
 
   class Visitor : public CefCookieVisitor {
    public:
-    Visitor(base::WaitableEvent* event, bool* cookie_exists)
+    Visitor(CefRefPtr<CefWaitableEvent> event, bool* cookie_exists)
       : event_(event),
         cookie_exists_(cookie_exists) {
       EXPECT_TRUE(event_);
@@ -213,24 +211,23 @@ void GetTestCookie(CefRefPtr<CefRequestContext> request_context,
     }
 
    private:
-    base::WaitableEvent* event_;
+    CefRefPtr<CefWaitableEvent> event_;
     bool* cookie_exists_;
 
     IMPLEMENT_REFCOUNTING(Visitor);
   };
 
-  base::WaitableEvent event(
+  CefRefPtr<CefWaitableEvent> event =
-      base::WaitableEvent::ResetPolicy::MANUAL,
+      CefWaitableEvent::CreateWaitableEvent(false, false);
-      base::WaitableEvent::InitialState::NOT_SIGNALED);
 
   CefRefPtr<CefCookieManager> cookie_manager =
       request_context->GetDefaultCookieManager(NULL);
   cookie_manager->VisitUrlCookies(
-      kRequestOrigin, true, new Visitor(&event, cookie_exists));
+      kRequestOrigin, true, new Visitor(event, cookie_exists));
 
   // Wait for the Visitor.
-  event.TimedWait(base::TimeDelta::FromSeconds(2));
+  event->TimedWait(2000);
-  EXPECT_TRUE(event.IsSignaled());
+  EXPECT_TRUE(event->IsSignaled());
 }
 
 
@@ -1487,16 +1484,15 @@ namespace {
 
 class InvalidURLTestClient : public CefURLRequestClient {
  public:
-  InvalidURLTestClient()
+  InvalidURLTestClient() {
-      : event_(base::WaitableEvent::ResetPolicy::AUTOMATIC,
+    event_ = CefWaitableEvent::CreateWaitableEvent(true, false);
-               base::WaitableEvent::InitialState::NOT_SIGNALED) {
   }
 
   void RunTest() {
     CefPostTask(TID_UI, base::Bind(&InvalidURLTestClient::RunOnUIThread, this));
 
     // Wait for the test to complete.
-    event_.Wait();
+    event_->Wait();
   }
 
   void OnRequestComplete(CefRefPtr<CefURLRequest> client) override {
@@ -1549,10 +1545,10 @@ class InvalidURLTestClient : public CefURLRequestClient {
   void CompleteOnUIThread() {
     EXPECT_UI_THREAD();
     // Signal that the test is complete.
-    event_.Signal();
+    event_->Signal();
   }
 
-  base::WaitableEvent event_;
+  CefRefPtr<CefWaitableEvent> event_;
 
   IMPLEMENT_REFCOUNTING(InvalidURLTestClient);
 };

tests/unittests/views/button_unittest.cc

@@ -246,7 +246,7 @@ void RunLabelButtonClick(bool with_frame,
                      kClickDelayMS);
 }
 
-void LabelButtonClick(base::WaitableEvent* event,
+void LabelButtonClick(CefRefPtr<CefWaitableEvent> event,
                       bool with_button_frame,
                       bool with_button_text,
                       bool with_button_image,
@@ -258,82 +258,82 @@ void LabelButtonClick(base::WaitableEvent* event,
 }
 
 void LabelButtonClickFramedWithTextWithImageFramedWindowImpl(
-    base::WaitableEvent* event) {
+    CefRefPtr<CefWaitableEvent> event) {
   LabelButtonClick(event, true, true, true, true);
 }
 
 void LabelButtonClickFramedWithTextNoImageFramedWindowImpl(
-    base::WaitableEvent* event) {
+    CefRefPtr<CefWaitableEvent> event) {
   LabelButtonClick(event, true, true, false, true);
 }
 
 void LabelButtonClickFramedWithTextWithImageFramelessWindowImpl(
-    base::WaitableEvent* event) {
+    CefRefPtr<CefWaitableEvent> event) {
   LabelButtonClick(event, true, true, true, false);
 }
 
 void LabelButtonClickFramedWithTextNoImageFramelessWindowImpl(
-    base::WaitableEvent* event) {
+    CefRefPtr<CefWaitableEvent> event) {
   LabelButtonClick(event, true, true, false, false);
 }
 
 void LabelButtonClickFramedNoTextWithImageFramedWindowImpl(
-    base::WaitableEvent* event) {
+    CefRefPtr<CefWaitableEvent> event) {
   LabelButtonClick(event, true, false, true, true);
 }
 
 void LabelButtonClickFramedNoTextNoImageFramedWindowImpl(
-    base::WaitableEvent* event) {
+    CefRefPtr<CefWaitableEvent> event) {
   LabelButtonClick(event, true, false, false, true);
 }
 
 void LabelButtonClickFramedNoTextWithImageFramelessWindowImpl(
-    base::WaitableEvent* event) {
+    CefRefPtr<CefWaitableEvent> event) {
   LabelButtonClick(event, true, false, true, false);
 }
 
 void LabelButtonClickFramedNoTextNoImageFramelessWindowImpl(
-    base::WaitableEvent* event) {
+    CefRefPtr<CefWaitableEvent> event) {
   LabelButtonClick(event, true, false, false, false);
 }
 
 void LabelButtonClickFramelessWithTextWithImageFramedWindowImpl(
-    base::WaitableEvent* event) {
+    CefRefPtr<CefWaitableEvent> event) {
   LabelButtonClick(event, false, true, true, true);
 }
 
 void LabelButtonClickFramelessWithTextNoImageFramedWindowImpl(
-    base::WaitableEvent* event) {
+    CefRefPtr<CefWaitableEvent> event) {
   LabelButtonClick(event, false, true, false, true);
 }
 
 void LabelButtonClickFramelessWithTextWithImageFramelessWindowImpl(
-    base::WaitableEvent* event) {
+    CefRefPtr<CefWaitableEvent> event) {
   LabelButtonClick(event, false, true, true, false);
 }
 
 void LabelButtonClickFramelessWithTextNoImageFramelessWindowImpl(
-    base::WaitableEvent* event) {
+    CefRefPtr<CefWaitableEvent> event) {
   LabelButtonClick(event, false, true, false, false);
 }
 
 void LabelButtonClickFramelessNoTextWithImageFramedWindowImpl(
-    base::WaitableEvent* event) {
+    CefRefPtr<CefWaitableEvent> event) {
   LabelButtonClick(event, false, false, true, true);
 }
 
 void LabelButtonClickFramelessNoTextNoImageFramedWindowImpl(
-    base::WaitableEvent* event) {
+    CefRefPtr<CefWaitableEvent> event) {
   LabelButtonClick(event, false, false, false, true);
 }
 
 void LabelButtonClickFramelessNoTextWithImageFramelessWindowImpl(
-    base::WaitableEvent* event) {
+    CefRefPtr<CefWaitableEvent> event) {
   LabelButtonClick(event, false, false, true, false);
 }
 
 void LabelButtonClickFramelessNoTextNoImageFramelessWindowImpl(
-    base::WaitableEvent* event) {
+    CefRefPtr<CefWaitableEvent> event) {
   LabelButtonClick(event, false, false, false, false);
 }
 
@@ -460,7 +460,7 @@ void RunMenuButtonClick(bool with_frame,
                      kClickDelayMS);
 }
 
-void MenuButtonClick(base::WaitableEvent* event,
+void MenuButtonClick(CefRefPtr<CefWaitableEvent> event,
                      bool with_button_frame,
                      bool with_button_text,
                      bool with_button_menu_marker,
@@ -473,162 +473,162 @@ void MenuButtonClick(base::WaitableEvent* event,
 }
 
 void MenuButtonClickFramedWithTextWithMarkerWithImageFramedWindowImpl(
-    base::WaitableEvent* event) {
+    CefRefPtr<CefWaitableEvent> event) {
   MenuButtonClick(event, true, true, true, true, true);
 }
 
 void MenuButtonClickFramedWithTextNoMarkerWithImageFramedWindowImpl(
-    base::WaitableEvent* event) {
+    CefRefPtr<CefWaitableEvent> event) {
   MenuButtonClick(event, true, true, false, true, true);
 }
 
 void MenuButtonClickFramedWithTextWithMarkerNoImageFramedWindowImpl(
-    base::WaitableEvent* event) {
+    CefRefPtr<CefWaitableEvent> event) {
   MenuButtonClick(event, true, true, true, false, true);
 }
 
 void MenuButtonClickFramedWithTextNoMarkerNoImageFramedWindowImpl(
-    base::WaitableEvent* event) {
+    CefRefPtr<CefWaitableEvent> event) {
   MenuButtonClick(event, true, true, false, false, true);
 }
 
 void MenuButtonClickFramedWithTextWithMarkerWithImageFramelessWindowImpl(
-    base::WaitableEvent* event) {
+    CefRefPtr<CefWaitableEvent> event) {
   MenuButtonClick(event, true, true, true, true, false);
 }
 
 void MenuButtonClickFramedWithTextNoMarkerWithImageFramelessWindowImpl(
-    base::WaitableEvent* event) {
+    CefRefPtr<CefWaitableEvent> event) {
   MenuButtonClick(event, true, true, false, true, false);
 }
 
 void MenuButtonClickFramedWithTextWithMarkerNoImageFramelessWindowImpl(
-    base::WaitableEvent* event) {
+    CefRefPtr<CefWaitableEvent> event) {
   MenuButtonClick(event, true, true, true, false, false);
 }
 
 void MenuButtonClickFramedWithTextNoMarkerNoImageFramelessWindowImpl(
-    base::WaitableEvent* event) {
+    CefRefPtr<CefWaitableEvent> event) {
   MenuButtonClick(event, true, true, false, false, false);
 }
 
 void MenuButtonClickFramedNoTextWithMarkerWithImageFramedWindowImpl(
-    base::WaitableEvent* event) {
+    CefRefPtr<CefWaitableEvent> event) {
   MenuButtonClick(event, true, false, true, true, true);
 }
 
 void MenuButtonClickFramedNoTextNoMarkerWithImageFramedWindowImpl(
-    base::WaitableEvent* event) {
+    CefRefPtr<CefWaitableEvent> event) {
   MenuButtonClick(event, true, false, false, true, true);
 }
 
 void MenuButtonClickFramedNoTextWithMarkerNoImageFramedWindowImpl(
-    base::WaitableEvent* event) {
+    CefRefPtr<CefWaitableEvent> event) {
   MenuButtonClick(event, true, false, true, false, true);
 }
 
 void MenuButtonClickFramedNoTextNoMarkerNoImageFramedWindowImpl(
-    base::WaitableEvent* event) {
+    CefRefPtr<CefWaitableEvent> event) {
   MenuButtonClick(event, true, false, false, false, true);
 }
 
 void MenuButtonClickFramedNoTextWithMarkerWithImageFramelessWindowImpl(
-    base::WaitableEvent* event) {
+    CefRefPtr<CefWaitableEvent> event) {
   MenuButtonClick(event, true, false, true, true, false);
 }
 
 void MenuButtonClickFramedNoTextNoMarkerWithImageFramelessWindowImpl(
-    base::WaitableEvent* event) {
+    CefRefPtr<CefWaitableEvent> event) {
   MenuButtonClick(event, true, false, false, true, false);
 }
 
 void MenuButtonClickFramedNoTextWithMarkerNoImageFramelessWindowImpl(
-    base::WaitableEvent* event) {
+    CefRefPtr<CefWaitableEvent> event) {
   MenuButtonClick(event, true, false, true, false, false);
 }
 
 void MenuButtonClickFramedNoTextNoMarkerNoImageFramelessWindowImpl(
-    base::WaitableEvent* event) {
+    CefRefPtr<CefWaitableEvent> event) {
   MenuButtonClick(event, true, false, false, false, false);
 }
 
 void MenuButtonClickFramelessWithTextWithMarkerWithImageFramedWindowImpl(
-    base::WaitableEvent* event) {
+    CefRefPtr<CefWaitableEvent> event) {
   MenuButtonClick(event, false, true, true, true, true);
 }
 
 void MenuButtonClickFramelessWithTextNoMarkerWithImageFramedWindowImpl(
-    base::WaitableEvent* event) {
+    CefRefPtr<CefWaitableEvent> event) {
   MenuButtonClick(event, false, true, false, true, true);
 }
 
 void MenuButtonClickFramelessWithTextWithMarkerNoImageFramedWindowImpl(
-    base::WaitableEvent* event) {
+    CefRefPtr<CefWaitableEvent> event) {
   MenuButtonClick(event, false, true, true, false, true);
 }
 
 void MenuButtonClickFramelessWithTextNoMarkerNoImageFramedWindowImpl(
-    base::WaitableEvent* event) {
+    CefRefPtr<CefWaitableEvent> event) {
   MenuButtonClick(event, false, true, false, false, true);
 }
 
 void MenuButtonClickFramelessWithTextWithMarkerWithImageFramelessWindowImpl(
-    base::WaitableEvent* event) {
+    CefRefPtr<CefWaitableEvent> event) {
   MenuButtonClick(event, false, true, true, true, false);
 }
 
 void MenuButtonClickFramelessWithTextNoMarkerWithImageFramelessWindowImpl(
-    base::WaitableEvent* event) {
+    CefRefPtr<CefWaitableEvent> event) {
   MenuButtonClick(event, false, true, false, true, false);
 }
 
 void MenuButtonClickFramelessWithTextWithMarkerNoImageFramelessWindowImpl(
-    base::WaitableEvent* event) {
+    CefRefPtr<CefWaitableEvent> event) {
   MenuButtonClick(event, false, true, true, false, false);
 }
 
 void MenuButtonClickFramelessWithTextNoMarkerNoImageFramelessWindowImpl(
-    base::WaitableEvent* event) {
+    CefRefPtr<CefWaitableEvent> event) {
   MenuButtonClick(event, false, true, false, false, false);
 }
 
 void MenuButtonClickFramelessNoTextWithMarkerWithImageFramedWindowImpl(
-    base::WaitableEvent* event) {
+    CefRefPtr<CefWaitableEvent> event) {
   MenuButtonClick(event, false, false, true, true, true);
 }
 
 void MenuButtonClickFramelessNoTextNoMarkerWithImageFramedWindowImpl(
-    base::WaitableEvent* event) {
+    CefRefPtr<CefWaitableEvent> event) {
   MenuButtonClick(event, false, false, false, true, true);
 }
 
 void MenuButtonClickFramelessNoTextWithMarkerNoImageFramedWindowImpl(
-    base::WaitableEvent* event) {
+    CefRefPtr<CefWaitableEvent> event) {
   MenuButtonClick(event, false, false, true, false, true);
 }
 
 void MenuButtonClickFramelessNoTextNoMarkerNoImageFramedWindowImpl(
-    base::WaitableEvent* event) {
+    CefRefPtr<CefWaitableEvent> event) {
   MenuButtonClick(event, false, false, false, false, true);
 }
 
 void MenuButtonClickFramelessNoTextWithMarkerWithImageFramelessWindowImpl(
-    base::WaitableEvent* event) {
+    CefRefPtr<CefWaitableEvent> event) {
   MenuButtonClick(event, false, false, true, true, false);
 }
 
 void MenuButtonClickFramelessNoTextNoMarkerWithImageFramelessWindowImpl(
-    base::WaitableEvent* event) {
+    CefRefPtr<CefWaitableEvent> event) {
   MenuButtonClick(event, false, false, false, true, false);
 }
 
 void MenuButtonClickFramelessNoTextWithMarkerNoImageFramelessWindowImpl(
-    base::WaitableEvent* event) {
+    CefRefPtr<CefWaitableEvent> event) {
   MenuButtonClick(event, false, false, true, false, false);
 }
 
 void MenuButtonClickFramelessNoTextNoMarkerNoImageFramelessWindowImpl(
-    base::WaitableEvent* event) {
+    CefRefPtr<CefWaitableEvent> event) {
   MenuButtonClick(event, false, false, false, false, false);
 }
 

tests/unittests/views/scroll_view_unittest.cc

@@ -132,17 +132,17 @@ void RunScrollViewLayout(bool with_delegate,
                     scroll_view_bounds.height - sb_height), visible_rect);
 }
 
-void ScrollViewLayout(base::WaitableEvent* event,
+void ScrollViewLayout(CefRefPtr<CefWaitableEvent> event,
                       bool with_delegate) {
   TestWindowDelegate::RunTest(event,
       base::Bind(RunScrollViewLayout, with_delegate), false);
 }
 
-void ScrollViewLayoutWithDelegateImpl(base::WaitableEvent* event) {
+void ScrollViewLayoutWithDelegateImpl(CefRefPtr<CefWaitableEvent> event) {
   ScrollViewLayout(event, true);
 }
 
-void ScrollViewLayoutNoDelegateImpl(base::WaitableEvent* event) {
+void ScrollViewLayoutNoDelegateImpl(CefRefPtr<CefWaitableEvent> event) {
   ScrollViewLayout(event, false);
 }
 

tests/unittests/views/test_window_delegate.cc

@@ -23,7 +23,7 @@ const int kTestTimeout = 5000;
 const int TestWindowDelegate::kWSize = 400;
 
 // static
-void TestWindowDelegate::RunTest(base::WaitableEvent* event,
+void TestWindowDelegate::RunTest(CefRefPtr<CefWaitableEvent> event,
                                  const WindowTest& window_test,
                                  bool frameless,
                                  bool close_window,
@@ -113,7 +113,7 @@ CefSize TestWindowDelegate::GetPreferredSize(CefRefPtr<CefView> view) {
   return CefSize(window_size_, window_size_);
 }
 
-TestWindowDelegate::TestWindowDelegate(base::WaitableEvent* event,
+TestWindowDelegate::TestWindowDelegate(CefRefPtr<CefWaitableEvent> event,
                                        const WindowTest& window_test,
                                        bool frameless,
                                        bool close_window,

tests/unittests/views/test_window_delegate.h

@@ -2,12 +2,12 @@
 // reserved. Use of this source code is governed by a BSD-style license that
 // can be found in the LICENSE file.
 
+#include "include/cef_waitable_event.h"
 #include "include/views/cef_window.h"
 #include "include/views/cef_window_delegate.h"
 
 #include "base/callback.h"
 #include "base/memory/weak_ptr.h"
-#include "base/synchronization/waitable_event.h"
 
 class TestWindowDelegate : public CefWindowDelegate {
  public:
@@ -23,7 +23,7 @@ class TestWindowDelegate : public CefWindowDelegate {
   // without a frame. If |close_window| is true the Window will be closed
   // immediately after |window_test| returns. Otherwise, the caller is
   // responsible for closing the Window passed to |window_test|.
-  static void RunTest(base::WaitableEvent* event,
+  static void RunTest(CefRefPtr<CefWaitableEvent> event,
                       const WindowTest& window_test,
                       bool frameless = false,
                       bool close_window = true,
@@ -36,7 +36,7 @@ class TestWindowDelegate : public CefWindowDelegate {
   CefSize GetPreferredSize(CefRefPtr<CefView> view) override;
 
  private:
-  TestWindowDelegate(base::WaitableEvent* event,
+  TestWindowDelegate(CefRefPtr<CefWaitableEvent> event,
                      const WindowTest& window_test,
                      bool frameless,
                      bool close_window,
@@ -46,7 +46,7 @@ class TestWindowDelegate : public CefWindowDelegate {
   void OnCloseWindow();
   void OnTimeoutWindow();
 
-  base::WaitableEvent* event_;
+  CefRefPtr<CefWaitableEvent> event_;
   WindowTest window_test_;
   bool frameless_;
   bool close_window_;

tests/unittests/views/textfield_unittest.cc

@@ -265,7 +265,7 @@ void RunTextfieldKeyEvent(CefRefPtr<CefWindow> window) {
   window->SendKeyPress(ui::VKEY_RETURN, 0);
 }
 
-void TextfieldKeyEventImpl(base::WaitableEvent* event) {
+void TextfieldKeyEventImpl(CefRefPtr<CefWaitableEvent> event) {
   TestWindowDelegate::RunTest(event,
       base::Bind(RunTextfieldKeyEvent), false, false);
 }

tests/unittests/views/window_unittest.cc

@@ -33,11 +33,11 @@ void ExpectCloseRects(const CefRect& expected,
   EXPECT_LE(abs(expected.height - actual.height), allowed_deviance);
 }
 
-void WindowCreateImpl(base::WaitableEvent* event) {
+void WindowCreateImpl(CefRefPtr<CefWaitableEvent> event) {
   TestWindowDelegate::RunTest(event, TestWindowDelegate::WindowTest(), false);
 }
 
-void WindowCreateFramelessImpl(base::WaitableEvent* event) {
+void WindowCreateFramelessImpl(CefRefPtr<CefWaitableEvent> event) {
   TestWindowDelegate::RunTest(event, TestWindowDelegate::WindowTest(), true);
 }
 
@@ -52,11 +52,11 @@ void RunWindowShowHide(CefRefPtr<CefWindow> window) {
   EXPECT_FALSE(window->IsDrawn());
 }
 
-void WindowShowHideImpl(base::WaitableEvent* event) {
+void WindowShowHideImpl(CefRefPtr<CefWaitableEvent> event) {
   TestWindowDelegate::RunTest(event, base::Bind(RunWindowShowHide), false);
 }
 
-void WindowShowHideFramelessImpl(base::WaitableEvent* event) {
+void WindowShowHideFramelessImpl(CefRefPtr<CefWaitableEvent> event) {
   TestWindowDelegate::RunTest(event, base::Bind(RunWindowShowHide), true);
 }
 
@@ -180,11 +180,11 @@ void RunWindowLayoutAndCoords(CefRefPtr<CefWindow> window) {
             point);
 }
 
-void WindowLayoutAndCoordsImpl(base::WaitableEvent* event) {
+void WindowLayoutAndCoordsImpl(CefRefPtr<CefWaitableEvent> event) {
   TestWindowDelegate::RunTest(event, base::Bind(RunWindowLayoutAndCoords), false);
 }
 
-void WindowLayoutAndCoordsFramelessImpl(base::WaitableEvent* event) {
+void WindowLayoutAndCoordsFramelessImpl(CefRefPtr<CefWaitableEvent> event) {
   TestWindowDelegate::RunTest(event, base::Bind(RunWindowLayoutAndCoords), true);
 }
 
@@ -223,12 +223,12 @@ void RunWindowMaximize(CefRefPtr<CefWindow> window) {
   CefPostDelayedTask(TID_UI, base::Bind(VerifyMaximize, window), kStateDelayMS);
 }
 
-void WindowMaximizeImpl(base::WaitableEvent* event) {
+void WindowMaximizeImpl(CefRefPtr<CefWaitableEvent> event) {
   TestWindowDelegate::RunTest(event, base::Bind(RunWindowMaximize), false,
                               false);
 }
 
-void WindowMaximizeFramelessImpl(base::WaitableEvent* event) {
+void WindowMaximizeFramelessImpl(CefRefPtr<CefWaitableEvent> event) {
   TestWindowDelegate::RunTest(event, base::Bind(RunWindowMaximize), true,
                               false);
 }
@@ -260,12 +260,12 @@ void RunWindowMinimize(CefRefPtr<CefWindow> window) {
   CefPostDelayedTask(TID_UI, base::Bind(VerifyMinimize, window), kStateDelayMS);
 }
 
-void WindowMinimizeImpl(base::WaitableEvent* event) {
+void WindowMinimizeImpl(CefRefPtr<CefWaitableEvent> event) {
   TestWindowDelegate::RunTest(event, base::Bind(RunWindowMinimize), false,
                               false);
 }
 
-void WindowMinimizeFramelessImpl(base::WaitableEvent* event) {
+void WindowMinimizeFramelessImpl(CefRefPtr<CefWaitableEvent> event) {
   TestWindowDelegate::RunTest(event, base::Bind(RunWindowMinimize), true,
                               false);
 }
@@ -307,12 +307,12 @@ void RunWindowFullscreen(CefRefPtr<CefWindow> window) {
                      kStateDelayMS);
 }
 
-void WindowFullscreenImpl(base::WaitableEvent* event) {
+void WindowFullscreenImpl(CefRefPtr<CefWaitableEvent> event) {
   TestWindowDelegate::RunTest(event, base::Bind(RunWindowFullscreen), false,
                               false);
 }
 
-void WindowFullscreenFramelessImpl(base::WaitableEvent* event) {
+void WindowFullscreenFramelessImpl(CefRefPtr<CefWaitableEvent> event) {
   TestWindowDelegate::RunTest(event, base::Bind(RunWindowFullscreen), true,
                               false);
 }
@@ -333,11 +333,11 @@ void RunWindowIcon(CefRefPtr<CefWindow> window) {
   window->Show();
 }
 
-void WindowIconImpl(base::WaitableEvent* event) {
+void WindowIconImpl(CefRefPtr<CefWaitableEvent> event) {
   TestWindowDelegate::RunTest(event, base::Bind(RunWindowIcon), false);
 }
 
-void WindowIconFramelessImpl(base::WaitableEvent* event) {
+void WindowIconFramelessImpl(CefRefPtr<CefWaitableEvent> event) {
   TestWindowDelegate::RunTest(event, base::Bind(RunWindowIcon), true);
 }
 

tests/unittests/waitable_event_unittest.cc

@@ -0,0 +1,78 @@
+// Copyright 2016 The Chromium Embedded Framework Authors. Portions copyright
+// 2012 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 "include/base/cef_bind.h"
+#include "include/cef_thread.h"
+#include "include/cef_waitable_event.h"
+#include "include/wrapper/cef_closure_task.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+// Test manual reset.
+TEST(WaitableEventTest, ManualReset) {
+  CefRefPtr<CefWaitableEvent> event =
+      CefWaitableEvent::CreateWaitableEvent(false, false);
+
+  EXPECT_FALSE(event->IsSignaled());
+
+  event->Signal();
+  EXPECT_TRUE(event->IsSignaled());
+  EXPECT_TRUE(event->IsSignaled());
+
+  event->Reset();
+  EXPECT_FALSE(event->IsSignaled());
+  EXPECT_FALSE(event->TimedWait(10));
+
+  event->Signal();
+  event->Wait();
+  EXPECT_TRUE(event->TimedWait(10));
+}
+
+// Test automatic reset.
+TEST(WaitableEventTest, AutomaticReset) {
+  CefRefPtr<CefWaitableEvent> event =
+      CefWaitableEvent::CreateWaitableEvent(true, false);
+
+  EXPECT_FALSE(event->IsSignaled());
+
+  event->Signal();
+  EXPECT_TRUE(event->IsSignaled());
+  EXPECT_FALSE(event->IsSignaled());
+
+  event->Reset();
+  EXPECT_FALSE(event->IsSignaled());
+  EXPECT_FALSE(event->TimedWait(10));
+
+  event->Signal();
+  event->Wait();
+  EXPECT_FALSE(event->TimedWait(10));
+
+  event->Signal();
+  EXPECT_TRUE(event->TimedWait(10));
+}
+
+namespace {
+
+void SignalEvent(CefWaitableEvent* event) {
+  event->Signal();
+}
+
+}  // namespace
+
+// Tests that a WaitableEvent can be safely deleted when |Wait| is done without
+// additional synchronization.
+TEST(WaitableEventTest, WaitAndDelete) {
+  CefRefPtr<CefWaitableEvent> event =
+      CefWaitableEvent::CreateWaitableEvent(true, false);
+
+  CefRefPtr<CefThread> thread = CefThread::CreateThread("waitable_event_test");
+  thread->GetTaskRunner()->PostDelayedTask(
+      CefCreateClosureTask(base::Bind(SignalEvent,
+                                      base::Unretained(event.get()))), 10);
+
+  event->Wait();
+  event = nullptr;
+
+  thread->Stop();
+  thread = nullptr;
+}