diff --git a/BUILD.gn b/BUILD.gn index c5e0fd073..d3c09dcd9 100644 --- a/BUILD.gn +++ b/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", diff --git a/cef_paths.gypi b/cef_paths.gypi index 60ed7f0e3..943b32d8f 100644 --- a/cef_paths.gypi +++ b/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', diff --git a/include/capi/cef_waitable_event_capi.h b/include/capi/cef_waitable_event_capi.h new file mode 100644 index 000000000..9d84bcb64 --- /dev/null +++ b/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_ diff --git a/include/cef_waitable_event.h b/include/cef_waitable_event.h new file mode 100644 index 000000000..4a4e9950c --- /dev/null +++ b/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 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_ diff --git a/libcef/common/waitable_event_impl.cc b/libcef/common/waitable_event_impl.cc new file mode 100644 index 000000000..b332a07c9 --- /dev/null +++ b/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::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)); +} diff --git a/libcef/common/waitable_event_impl.h b/libcef/common/waitable_event_impl.h new file mode 100644 index 000000000..c88e9c48f --- /dev/null +++ b/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_ diff --git a/libcef_dll/cpptoc/waitable_event_cpptoc.cc b/libcef_dll/cpptoc/waitable_event_cpptoc.cc new file mode 100644 index 000000000..835d0730e --- /dev/null +++ b/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 _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 CefCppToC::UnwrapDerived(CefWrapperType type, + cef_waitable_event_t* s) { + NOTREACHED() << "Unexpected class type: " << type; + return NULL; +} + +#if DCHECK_IS_ON() +template<> base::AtomicRefCount CefCppToC::DebugObjCt = 0; +#endif + +template<> CefWrapperType CefCppToC::kWrapperType = WT_WAITABLE_EVENT; diff --git a/libcef_dll/cpptoc/waitable_event_cpptoc.h b/libcef_dll/cpptoc/waitable_event_cpptoc.h new file mode 100644 index 000000000..43d2afa2b --- /dev/null +++ b/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 { + public: + CefWaitableEventCppToC(); +}; + +#endif // BUILDING_CEF_SHARED +#endif // CEF_LIBCEF_DLL_CPPTOC_WAITABLE_EVENT_CPPTOC_H_ diff --git a/libcef_dll/ctocpp/waitable_event_ctocpp.cc b/libcef_dll/ctocpp/waitable_event_ctocpp.cc new file mode 100644 index 000000000..dfd9e283e --- /dev/null +++ b/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::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::UnwrapDerived(CefWrapperType type, + CefWaitableEvent* c) { + NOTREACHED() << "Unexpected class type: " << type; + return NULL; +} + +#if DCHECK_IS_ON() +template<> base::AtomicRefCount CefCToCpp::DebugObjCt = 0; +#endif + +template<> CefWrapperType CefCToCpp::kWrapperType = WT_WAITABLE_EVENT; diff --git a/libcef_dll/ctocpp/waitable_event_ctocpp.h b/libcef_dll/ctocpp/waitable_event_ctocpp.h new file mode 100644 index 000000000..b9f42fedd --- /dev/null +++ b/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 { + 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_ diff --git a/libcef_dll/libcef_dll.cc b/libcef_dll/libcef_dll.cc index 5b335758a..2e353f5b4 100644 --- a/libcef_dll/libcef_dll.cc +++ b/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)); diff --git a/libcef_dll/wrapper/libcef_dll_wrapper.cc b/libcef_dll/wrapper/libcef_dll_wrapper.cc index cdca83231..5e6ba876c 100644 --- a/libcef_dll/wrapper/libcef_dll_wrapper.cc +++ b/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)); diff --git a/libcef_dll/wrapper_types.h b/libcef_dll/wrapper_types.h index 354f58b25..9e6b25f72 100644 --- a/libcef_dll/wrapper_types.h +++ b/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, diff --git a/tests/unittests/cookie_unittest.cc b/tests/unittests/cookie_unittest.cc index ad7a466b3..ba5a94593 100644 --- a/tests/unittests/cookie_unittest.cc +++ b/tests/unittests/cookie_unittest.cc @@ -4,13 +4,12 @@ #include -#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 CookieVector; class TestCompletionCallback : public CefCompletionCallback { public: - explicit TestCompletionCallback(base::WaitableEvent* event) + explicit TestCompletionCallback(CefRefPtr event) : event_(event) {} void OnComplete() override { @@ -39,7 +38,7 @@ class TestCompletionCallback : public CefCompletionCallback { } private: - base::WaitableEvent* event_; + CefRefPtr 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 event) : expected_success_(expected_success), event_(event) {} @@ -59,7 +58,7 @@ class TestSetCookieCallback : public CefSetCookieCallback { private: bool expected_success_; - base::WaitableEvent* event_; + CefRefPtr 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 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 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 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 event_; IMPLEMENT_REFCOUNTING(TestVisitor); }; @@ -117,12 +116,12 @@ class TestVisitor : public CefCookieVisitor { void SetCookies(CefRefPtr manager, const CefString& url, const CookieVector& cookies, bool expected_success, - base::WaitableEvent& event) { + CefRefPtr event) { CookieVector::const_iterator it = cookies.begin(); for (; it != cookies.end(); ++it) { EXPECT_TRUE(manager->SetCookie( - url, *it, new TestSetCookieCallback(expected_success, &event))); - event.Wait(); + url, *it, new TestSetCookieCallback(expected_success, event))); + event->Wait(); } } @@ -130,11 +129,11 @@ void SetCookies(CefRefPtr manager, void DeleteCookies(CefRefPtr manager, const CefString& url, const CefString& cookie_name, int expected_num_deleted, - base::WaitableEvent& event) { + CefRefPtr event) { EXPECT_TRUE(manager->DeleteCookies( url, cookie_name, - new TestDeleteCookiesCallback(expected_num_deleted, &event))); - event.Wait(); + new TestDeleteCookiesCallback(expected_num_deleted, event))); + event->Wait(); } // Create a test cookie. If |withDomain| is true a domain cookie will be @@ -142,7 +141,7 @@ void DeleteCookies(CefRefPtr manager, void CreateCookie(CefRefPtr manager, CefCookie& cookie, bool withDomain, bool sessionCookie, - base::WaitableEvent& event) { + CefRefPtr event) { CefString(&cookie.name).FromASCII("my_cookie"); CefString(&cookie.value).FromASCII("My Value"); if (withDomain) @@ -167,13 +166,13 @@ void CreateCookie(CefRefPtr manager, // the cookie will be deleted when it's retrieved. void GetCookie(CefRefPtr manager, const CefCookie& cookie, bool withDomain, - base::WaitableEvent& event, bool deleteCookies) { + CefRefPtr event, bool deleteCookies) { CookieVector cookies; // Get the cookie and delete it. EXPECT_TRUE(manager->VisitUrlCookies(kTestUrl, false, - new TestVisitor(&cookies, deleteCookies, &event))); - event.Wait(); + new TestVisitor(&cookies, deleteCookies, event))); + event->Wait(); EXPECT_EQ(1U, cookies.size()); if (cookies.size() != 1U) @@ -204,49 +203,49 @@ void VisitUrlCookies(CefRefPtr manager, bool includeHttpOnly, CookieVector& cookies, bool deleteCookies, - base::WaitableEvent& event) { + CefRefPtr event) { EXPECT_TRUE(manager->VisitUrlCookies(url, includeHttpOnly, - new TestVisitor(&cookies, deleteCookies, &event))); - event.Wait(); + new TestVisitor(&cookies, deleteCookies, event))); + event->Wait(); } // Visit all cookies. void VisitAllCookies(CefRefPtr manager, CookieVector& cookies, bool deleteCookies, - base::WaitableEvent& event) { + CefRefPtr event) { EXPECT_TRUE(manager->VisitAllCookies( - new TestVisitor(&cookies, deleteCookies, &event))); - event.Wait(); + new TestVisitor(&cookies, deleteCookies, event))); + event->Wait(); } // Verify that no cookies exist. If |withUrl| is true it will only check for // cookies matching the URL. void VerifyNoCookies(CefRefPtr manager, - base::WaitableEvent& event, bool withUrl) { + CefRefPtr 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 manager, - base::WaitableEvent& event) { + CefRefPtr event) { DeleteCookies(manager, CefString(), CefString(), kIgnoreNumDeleted, event); } void TestDomainCookie(CefRefPtr manager, - base::WaitableEvent& event) { + CefRefPtr event) { CefCookie cookie; // Create a domain cookie. @@ -260,7 +259,7 @@ void TestDomainCookie(CefRefPtr manager, } void TestHostCookie(CefRefPtr manager, - base::WaitableEvent& event) { + CefRefPtr event) { CefCookie cookie; // Create a host cookie. @@ -274,7 +273,7 @@ void TestHostCookie(CefRefPtr manager, } void TestMultipleCookies(CefRefPtr manager, - base::WaitableEvent& event) { + CefRefPtr event) { std::stringstream ss; int i; @@ -369,7 +368,7 @@ void TestMultipleCookies(CefRefPtr manager, } void TestAllCookies(CefRefPtr manager, - base::WaitableEvent& event) { + CefRefPtr event) { CookieVector cookies; // Delete all system cookies just in case something is left over from a @@ -446,7 +445,7 @@ void TestAllCookies(CefRefPtr manager, } void TestChangeDirectory(CefRefPtr manager, - base::WaitableEvent& event, + CefRefPtr event, const CefString& original_dir) { CefCookie cookie; @@ -502,13 +501,12 @@ void TestChangeDirectory(CefRefPtr manager, // Test creation of a domain cookie. TEST(CookieTest, DomainCookieGlobal) { - base::WaitableEvent event( - base::WaitableEvent::ResetPolicy::AUTOMATIC, - base::WaitableEvent::InitialState::NOT_SIGNALED); + CefRefPtr event = + CefWaitableEvent::CreateWaitableEvent(true, false); CefRefPtr manager = - CefCookieManager::GetGlobalManager(new TestCompletionCallback(&event)); - event.Wait(); + CefCookieManager::GetGlobalManager(new TestCompletionCallback(event)); + 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( - base::WaitableEvent::ResetPolicy::AUTOMATIC, - base::WaitableEvent::InitialState::NOT_SIGNALED); + CefRefPtr event = + CefWaitableEvent::CreateWaitableEvent(true, false); CefRefPtr manager = CefCookieManager::CreateManager(CefString(), false, - new TestCompletionCallback(&event)); - event.Wait(); + new TestCompletionCallback(event)); + 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( - base::WaitableEvent::ResetPolicy::AUTOMATIC, - base::WaitableEvent::InitialState::NOT_SIGNALED); + CefRefPtr event = + CefWaitableEvent::CreateWaitableEvent(true, false); CefRefPtr manager = CefCookieManager::CreateManager(temp_dir.GetPath(), false, - new TestCompletionCallback(&event)); - event.Wait(); + new TestCompletionCallback(event)); + 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( - base::WaitableEvent::ResetPolicy::AUTOMATIC, - base::WaitableEvent::InitialState::NOT_SIGNALED); + CefRefPtr event = + CefWaitableEvent::CreateWaitableEvent(true, false); CefRefPtr manager = - CefCookieManager::GetGlobalManager(new TestCompletionCallback(&event)); - event.Wait(); + CefCookieManager::GetGlobalManager(new TestCompletionCallback(event)); + 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( - base::WaitableEvent::ResetPolicy::AUTOMATIC, - base::WaitableEvent::InitialState::NOT_SIGNALED); + CefRefPtr event = + CefWaitableEvent::CreateWaitableEvent(true, false); CefRefPtr manager = CefCookieManager::CreateManager(CefString(), false, - new TestCompletionCallback(&event)); - event.Wait(); + new TestCompletionCallback(event)); + 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( - base::WaitableEvent::ResetPolicy::AUTOMATIC, - base::WaitableEvent::InitialState::NOT_SIGNALED); + CefRefPtr event = + CefWaitableEvent::CreateWaitableEvent(true, false); CefRefPtr manager = CefCookieManager::CreateManager(temp_dir.GetPath(), false, - new TestCompletionCallback(&event)); - event.Wait(); + new TestCompletionCallback(event)); + 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( - base::WaitableEvent::ResetPolicy::AUTOMATIC, - base::WaitableEvent::InitialState::NOT_SIGNALED); + CefRefPtr event = + CefWaitableEvent::CreateWaitableEvent(true, false); CefRefPtr manager = - CefCookieManager::GetGlobalManager(new TestCompletionCallback(&event)); - event.Wait(); + CefCookieManager::GetGlobalManager(new TestCompletionCallback(event)); + 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( - base::WaitableEvent::ResetPolicy::AUTOMATIC, - base::WaitableEvent::InitialState::NOT_SIGNALED); + CefRefPtr event = + CefWaitableEvent::CreateWaitableEvent(true, false); CefRefPtr manager = CefCookieManager::CreateManager(CefString(), false, - new TestCompletionCallback(&event)); - event.Wait(); + new TestCompletionCallback(event)); + 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( - base::WaitableEvent::ResetPolicy::AUTOMATIC, - base::WaitableEvent::InitialState::NOT_SIGNALED); + CefRefPtr event = + CefWaitableEvent::CreateWaitableEvent(true, false); CefRefPtr manager = CefCookieManager::CreateManager(temp_dir.GetPath(), false, - new TestCompletionCallback(&event)); - event.Wait(); + new TestCompletionCallback(event)); + event->Wait(); EXPECT_TRUE(manager.get()); TestMultipleCookies(manager, event); @@ -663,27 +653,25 @@ TEST(CookieTest, MultipleCookiesOnDisk) { } TEST(CookieTest, AllCookiesGlobal) { - base::WaitableEvent event( - base::WaitableEvent::ResetPolicy::AUTOMATIC, - base::WaitableEvent::InitialState::NOT_SIGNALED); + CefRefPtr event = + CefWaitableEvent::CreateWaitableEvent(true, false); CefRefPtr manager = - CefCookieManager::GetGlobalManager(new TestCompletionCallback(&event)); - event.Wait(); + CefCookieManager::GetGlobalManager(new TestCompletionCallback(event)); + event->Wait(); EXPECT_TRUE(manager.get()); TestAllCookies(manager, event); } TEST(CookieTest, AllCookiesInMemory) { - base::WaitableEvent event( - base::WaitableEvent::ResetPolicy::AUTOMATIC, - base::WaitableEvent::InitialState::NOT_SIGNALED); + CefRefPtr event = + CefWaitableEvent::CreateWaitableEvent(true, false); CefRefPtr manager = CefCookieManager::CreateManager(CefString(), false, - new TestCompletionCallback(&event)); - event.Wait(); + new TestCompletionCallback(event)); + 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( - base::WaitableEvent::ResetPolicy::AUTOMATIC, - base::WaitableEvent::InitialState::NOT_SIGNALED); + CefRefPtr event = + CefWaitableEvent::CreateWaitableEvent(true, false); CefRefPtr manager = CefCookieManager::CreateManager(temp_dir.GetPath(), false, - new TestCompletionCallback(&event)); - event.Wait(); + new TestCompletionCallback(event)); + event->Wait(); EXPECT_TRUE(manager.get()); TestAllCookies(manager, event); @@ -714,13 +701,12 @@ TEST(CookieTest, AllCookiesOnDisk) { } TEST(CookieTest, ChangeDirectoryGlobal) { - base::WaitableEvent event( - base::WaitableEvent::ResetPolicy::AUTOMATIC, - base::WaitableEvent::InitialState::NOT_SIGNALED); + CefRefPtr event = + CefWaitableEvent::CreateWaitableEvent(true, false); CefRefPtr manager = - CefCookieManager::GetGlobalManager(new TestCompletionCallback(&event)); - event.Wait(); + CefCookieManager::GetGlobalManager(new TestCompletionCallback(event)); + event->Wait(); EXPECT_TRUE(manager.get()); std::string cache_path; @@ -730,14 +716,13 @@ TEST(CookieTest, ChangeDirectoryGlobal) { } TEST(CookieTest, ChangeDirectoryCreated) { - base::WaitableEvent event( - base::WaitableEvent::ResetPolicy::AUTOMATIC, - base::WaitableEvent::InitialState::NOT_SIGNALED); + CefRefPtr event = + CefWaitableEvent::CreateWaitableEvent(true, false); CefRefPtr manager = CefCookieManager::CreateManager(CefString(), false, - new TestCompletionCallback(&event)); - event.Wait(); + new TestCompletionCallback(event)); + 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( - base::WaitableEvent::ResetPolicy::AUTOMATIC, - base::WaitableEvent::InitialState::NOT_SIGNALED); + CefRefPtr event = + CefWaitableEvent::CreateWaitableEvent(true, false); CefCookie cookie; // Create a new temporary directory. @@ -755,8 +739,8 @@ TEST(CookieTest, SessionCookieNoPersist) { CefRefPtr manager = CefCookieManager::CreateManager(temp_dir.GetPath(), false, - new TestCompletionCallback(&event)); - event.Wait(); + new TestCompletionCallback(event)); + 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)); - event.Wait(); + manager->FlushStore(new TestCompletionCallback(event)); + event->Wait(); // Create a new manager to read the same cookie store. manager = CefCookieManager::CreateManager(temp_dir.GetPath(), false, - new TestCompletionCallback(&event)); - event.Wait(); + new TestCompletionCallback(event)); + 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( - base::WaitableEvent::ResetPolicy::AUTOMATIC, - base::WaitableEvent::InitialState::NOT_SIGNALED); + CefRefPtr event = + CefWaitableEvent::CreateWaitableEvent(true, false); CefCookie cookie; // Create a new temporary directory. @@ -791,8 +774,8 @@ TEST(CookieTest, SessionCookieWillPersist) { CefRefPtr manager = CefCookieManager::CreateManager(temp_dir.GetPath(), true, - new TestCompletionCallback(&event)); - event.Wait(); + new TestCompletionCallback(event)); + 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)); - event.Wait(); + manager->FlushStore(new TestCompletionCallback(event)); + event->Wait(); // Create a new manager to read the same cookie store. manager = CefCookieManager::CreateManager(temp_dir.GetPath(), true, - new TestCompletionCallback(&event)); - event.Wait(); + new TestCompletionCallback(event)); + 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 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 browser, CefRefPtr frame, int httpStatusCode) override { std::string url = frame->GetURL(); if (url == kCookieJSUrl1) { got_load_end1_.yes(); - VerifyCookie(manager1_, url, "name1", "value1", got_cookie1_); - - // Go to the next URL - context_handler_->SetURL(kCookieJSUrl2); - frame->LoadURL(kCookieJSUrl2); + VerifyCookie(manager1_, url, "name1", "value1", &got_cookie1_, + base::Bind(&CookieTestJSHandler::LoadNextURL, this, frame)); } else { got_load_end2_.yes(); - VerifyCookie(manager2_, url, "name2", "value2", got_cookie2_); - - DestroyTest(); + VerifyCookie(manager2_, url, "name2", "value2", &got_cookie2_, + base::Bind(&CookieTestJSHandler::CompleteTest, this)); } } @@ -927,10 +928,18 @@ class CookieTestJSHandler : public TestHandler { const std::string& url, const std::string& name, const std::string& value, - TrackCallback& callback) { - base::WaitableEvent event( - base::WaitableEvent::ResetPolicy::AUTOMATIC, - base::WaitableEvent::InitialState::NOT_SIGNALED); + TrackCallback* callback, + const base::Closure& continue_callback) { + if (!CefCurrentlyOn(TID_FILE)) { + CefPostTask(TID_FILE, + base::Bind(&CookieTestJSHandler::VerifyCookie, this, manager, url, + name, value, base::Unretained(callback), + continue_callback)); + return; + } + + CefRefPtr 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 context_handler_; @@ -1163,33 +1174,50 @@ class CookieTestSchemeHandler : public TestHandler { SetTestTimeout(); } + // Go to the next URL. + void LoadNextURL(CefRefPtr frame, const std::string& url) { + if (!CefCurrentlyOn(TID_UI)) { + CefPostTask(TID_UI, + base::Bind(&CookieTestSchemeHandler::LoadNextURL, this, frame, url)); + return; + } + + context_handler_->SetURL(url); + frame->LoadURL(url); + } + + void CompleteTest(CefRefPtr browser) { + if (!CefCurrentlyOn(TID_UI)) { + CefPostTask(TID_UI, + base::Bind(&CookieTestSchemeHandler::CompleteTest, this, browser)); + return; + } + + // Unregister the scheme handler. + browser->GetHost()->GetRequestContext()->RegisterSchemeHandlerFactory( + scheme_, "cookie-tests", NULL); + + DestroyTest(); + } + void OnLoadEnd(CefRefPtr browser, CefRefPtr frame, int httpStatusCode) override { std::string url = frame->GetURL(); if (url == url1_) { got_load_end1_.yes(); - VerifyCookie(manager1_, url, "name1", "value1", got_cookie1_); - - // Go to the next URL - context_handler_->SetURL(url2_); - frame->LoadURL(url2_); + 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_); - - // Go to the next URL - context_handler_->SetURL(url3_); - frame->LoadURL(url3_); + 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_); - - // Unregister the scheme handler. - browser->GetHost()->GetRequestContext()->RegisterSchemeHandlerFactory( - scheme_, "cookie-tests", NULL); - - DestroyTest(); + VerifyCookie(manager2_, url, "name2", "value2", &got_cookie3_, + base::Bind(&CookieTestSchemeHandler::CompleteTest, this, browser)); } } @@ -1205,10 +1233,18 @@ class CookieTestSchemeHandler : public TestHandler { const std::string& url, const std::string& name, const std::string& value, - TrackCallback& callback) { - base::WaitableEvent event( - base::WaitableEvent::ResetPolicy::AUTOMATIC, - base::WaitableEvent::InitialState::NOT_SIGNALED); + TrackCallback* callback, + const base::Closure& continue_callback) { + if (!CefCurrentlyOn(TID_FILE)) { + CefPostTask(TID_FILE, + base::Bind(&CookieTestSchemeHandler::VerifyCookie, this, manager, url, + name, value, base::Unretained(callback), + continue_callback)); + return; + } + + CefRefPtr 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_; diff --git a/tests/unittests/geolocation_unittest.cc b/tests/unittests/geolocation_unittest.cc index 81291a1cf..d48aaa1f1 100644 --- a/tests/unittests/geolocation_unittest.cc +++ b/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 event) : event_(event) { } @@ -219,7 +218,7 @@ class TestGetGeolocationCallback : public CefGetGeolocationCallback { } private: - base::WaitableEvent* event_; + CefRefPtr event_; IMPLEMENT_REFCOUNTING(TestGetGeolocationCallback); }; @@ -227,9 +226,8 @@ private: } // namespace TEST(GeolocationTest, GetGeolocation) { - base::WaitableEvent event( - base::WaitableEvent::ResetPolicy::AUTOMATIC, - base::WaitableEvent::InitialState::NOT_SIGNALED); - CefGetGeolocation(new TestGetGeolocationCallback(&event)); - event.Wait(); + CefRefPtr event = + CefWaitableEvent::CreateWaitableEvent(true, false); + CefGetGeolocation(new TestGetGeolocationCallback(event)); + event->Wait(); } diff --git a/tests/unittests/preference_unittest.cc b/tests/unittests/preference_unittest.cc index 19140fe79..628062279 100644 --- a/tests/unittests/preference_unittest.cc +++ b/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 root, // Validate getting default values. void ValidateDefaults(CefRefPtr context, bool reset, - base::WaitableEvent* event) { + CefRefPtr event) { if (!CefCurrentlyOn(TID_UI)) { CefPostTask(TID_UI, base::Bind(ValidateDefaults, context, reset, event)); return; @@ -317,7 +316,7 @@ void PopulateRootSet(CefRefPtr val) { // Validate getting and setting values. void ValidateSetGet(CefRefPtr context, - base::WaitableEvent* event) { + CefRefPtr event) { if (!CefCurrentlyOn(TID_UI)) { CefPostTask(TID_UI, base::Bind(ValidateSetGet, context, event)); return; @@ -354,7 +353,7 @@ void ValidateSetGet(CefRefPtr context, // Validate getting values. void ValidateGet(CefRefPtr context, - base::WaitableEvent* event) { + CefRefPtr 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( - base::WaitableEvent::ResetPolicy::AUTOMATIC, - base::WaitableEvent::InitialState::NOT_SIGNALED); + CefRefPtr event = + CefWaitableEvent::CreateWaitableEvent(true, false); CefRefPtr context = CefRequestContext::GetGlobalContext(); EXPECT_TRUE(context.get()); - ValidateDefaults(context, false, &event); - event.Wait(); + ValidateDefaults(context, false, event); + event->Wait(); } // Verify setting/getting preference values on the global context. TEST(PreferenceTest, GlobalSetGet) { - base::WaitableEvent event( - base::WaitableEvent::ResetPolicy::AUTOMATIC, - base::WaitableEvent::InitialState::NOT_SIGNALED); + CefRefPtr event = + CefWaitableEvent::CreateWaitableEvent(true, false); CefRefPtr context = CefRequestContext::GetGlobalContext(); EXPECT_TRUE(context.get()); - ValidateSetGet(context, &event); - event.Wait(); + ValidateSetGet(context, event); + event->Wait(); // Reset to the default values. - ValidateDefaults(context, true, &event); - event.Wait(); + ValidateDefaults(context, true, event); + event->Wait(); } // Verify setting/getting preference values on shared global contexts. TEST(PreferenceTest, GlobalSetGetShared) { - base::WaitableEvent event( - base::WaitableEvent::ResetPolicy::AUTOMATIC, - base::WaitableEvent::InitialState::NOT_SIGNALED); + CefRefPtr event = + CefWaitableEvent::CreateWaitableEvent(true, false); CefRefPtr 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); - event.Wait(); + ValidateSetGet(context, event); + event->Wait(); // Get the values from the 2nd and 3rd contexts. They should be the same. - ValidateGet(context2, &event); - event.Wait(); - ValidateGet(context3, &event); - event.Wait(); + ValidateGet(context2, event); + event->Wait(); + ValidateGet(context3, event); + event->Wait(); // Get the values from the 4th context. They should be at the default. - ValidateDefaults(context4, false, &event); - event.Wait(); + ValidateDefaults(context4, false, event); + event->Wait(); // Reset to the default values. - ValidateDefaults(context, true, &event); - event.Wait(); + ValidateDefaults(context, true, event); + event->Wait(); } // Verify default preference values on a custom context. TEST(PreferenceTest, CustomDefaults) { - base::WaitableEvent event( - base::WaitableEvent::ResetPolicy::AUTOMATIC, - base::WaitableEvent::InitialState::NOT_SIGNALED); + CefRefPtr event = + CefWaitableEvent::CreateWaitableEvent(true, false); CefRequestContextSettings settings; CefRefPtr context = CefRequestContext::CreateContext(settings, NULL); EXPECT_TRUE(context.get()); - ValidateDefaults(context, false, &event); - event.Wait(); + ValidateDefaults(context, false, event); + event->Wait(); } // Verify setting/getting preference values on a custom context. TEST(PreferenceTest, CustomSetGet) { - base::WaitableEvent event( - base::WaitableEvent::ResetPolicy::AUTOMATIC, - base::WaitableEvent::InitialState::NOT_SIGNALED);; + CefRefPtr event = + CefWaitableEvent::CreateWaitableEvent(true, false); CefRequestContextSettings settings; CefRefPtr context = CefRequestContext::CreateContext(settings, NULL); EXPECT_TRUE(context.get()); - ValidateSetGet(context, &event); - event.Wait(); + ValidateSetGet(context, event); + event->Wait(); // Reset to the default values. - ValidateDefaults(context, true, &event); - event.Wait(); + ValidateDefaults(context, true, event); + event->Wait(); } // Verify setting/getting preference values on shared custom contexts. TEST(PreferenceTest, CustomSetGetShared) { - base::WaitableEvent event( - base::WaitableEvent::ResetPolicy::AUTOMATIC, - base::WaitableEvent::InitialState::NOT_SIGNALED); + CefRefPtr event = + CefWaitableEvent::CreateWaitableEvent(true, false); CefRequestContextSettings settings; CefRefPtr context = @@ -535,22 +528,22 @@ TEST(PreferenceTest, CustomSetGetShared) { EXPECT_TRUE(context.get()); // Set/get the values on the first context. - ValidateSetGet(context, &event); - event.Wait(); + ValidateSetGet(context, event); + event->Wait(); // Get the values from the 2nd and 3d contexts. They should be the same. - ValidateGet(context2, &event); - event.Wait(); - ValidateGet(context3, &event); - event.Wait(); + ValidateGet(context2, event); + event->Wait(); + ValidateGet(context3, event); + event->Wait(); // Get the values from the 4th context. They should be at the default. - ValidateDefaults(context4, false, &event); - event.Wait(); + ValidateDefaults(context4, false, event); + event->Wait(); // Reset to the default values. - ValidateDefaults(context, true, &event); - event.Wait(); + ValidateDefaults(context, true, event); + event->Wait(); } diff --git a/tests/unittests/task_unittest.cc b/tests/unittests/task_unittest.cc index e497e5b36..e076e6214 100644 --- a/tests/unittests/task_unittest.cc +++ b/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 runner = CefTaskRunner::GetForCurrentThread(); EXPECT_TRUE(runner.get()); EXPECT_TRUE(runner->BelongsToCurrentThread()); - EXPECT_TRUE(runner->BelongsToThread(TID_UI)); - EXPECT_FALSE(runner->BelongsToThread(TID_IO)); + EXPECT_TRUE(runner->BelongsToThread(TID_FILE)); + EXPECT_FALSE(runner->BelongsToThread(TID_DB)); EXPECT_TRUE(runner->IsSame(runner)); CefRefPtr 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. - CefRefPtr runner3 = CefTaskRunner::GetForThread(TID_IO); + // Not on the DB thread. + CefRefPtr 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. - CefRefPtr runner = CefTaskRunner::GetForThread(TID_IO); + // Currently on the FILE thread. + CefRefPtr runner = CefTaskRunner::GetForThread(TID_DB); EXPECT_TRUE(runner.get()); EXPECT_FALSE(runner->BelongsToCurrentThread()); - EXPECT_TRUE(runner->BelongsToThread(TID_IO)); - EXPECT_FALSE(runner->BelongsToThread(TID_UI)); + EXPECT_TRUE(runner->BelongsToThread(TID_DB)); + EXPECT_FALSE(runner->BelongsToThread(TID_FILE)); EXPECT_TRUE(runner->IsSame(runner)); - CefRefPtr runner2 = CefTaskRunner::GetForThread(TID_IO); + CefRefPtr runner2 = CefTaskRunner::GetForThread(TID_DB); EXPECT_TRUE(runner2.get()); EXPECT_TRUE(runner->IsSame(runner2)); EXPECT_TRUE(runner2->IsSame(runner)); - CefRefPtr runner3 = CefTaskRunner::GetForThread(TID_UI); + CefRefPtr 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 runner) { - // Currently on the IO thread. + // Currently on the DB thread. EXPECT_TRUE(runner->BelongsToCurrentThread()); - EXPECT_TRUE(runner->BelongsToThread(TID_IO)); - EXPECT_FALSE(runner->BelongsToThread(TID_UI)); + EXPECT_TRUE(runner->BelongsToThread(TID_DB)); + EXPECT_FALSE(runner->BelongsToThread(TID_FILE)); - // Current thread should be the IO thread. + // Current thread should be the DB thread. CefRefPtr runner2 = CefTaskRunner::GetForCurrentThread(); EXPECT_TRUE(runner2.get()); EXPECT_TRUE(runner2->BelongsToCurrentThread()); - EXPECT_TRUE(runner2->BelongsToThread(TID_IO)); - EXPECT_FALSE(runner2->BelongsToThread(TID_UI)); + EXPECT_TRUE(runner2->BelongsToThread(TID_DB)); + EXPECT_FALSE(runner2->BelongsToThread(TID_FILE)); EXPECT_TRUE(runner->IsSame(runner2)); EXPECT_TRUE(runner2->IsSame(runner)); - // Current thread should be the IO thread. - CefRefPtr runner3 = CefTaskRunner::GetForThread(TID_IO); + // Current thread should be the DB thread. + CefRefPtr runner3 = CefTaskRunner::GetForThread(TID_DB); EXPECT_TRUE(runner3.get()); EXPECT_TRUE(runner3->BelongsToCurrentThread()); - EXPECT_TRUE(runner3->BelongsToThread(TID_IO)); - EXPECT_FALSE(runner3->BelongsToThread(TID_UI)); + EXPECT_TRUE(runner3->BelongsToThread(TID_DB)); + EXPECT_FALSE(runner3->BelongsToThread(TID_FILE)); EXPECT_TRUE(runner->IsSame(runner3)); EXPECT_TRUE(runner3->IsSame(runner)); - // Current thread should not be the UI thread. - CefRefPtr runner4 = CefTaskRunner::GetForThread(TID_UI); + // Current thread should not be the FILE thread. + CefRefPtr runner4 = CefTaskRunner::GetForThread(TID_FILE); EXPECT_TRUE(runner4.get()); EXPECT_FALSE(runner4->BelongsToCurrentThread()); - EXPECT_FALSE(runner4->BelongsToThread(TID_IO)); - EXPECT_TRUE(runner4->BelongsToThread(TID_UI)); + EXPECT_FALSE(runner4->BelongsToThread(TID_DB)); + 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 runner) { } void PostTask1(bool* ran_test) { - // Currently on the UI thread. - CefRefPtr runner = CefTaskRunner::GetForThread(TID_IO); + // Currently on the FILE thread. + CefRefPtr 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. - CefRefPtr runner = CefTaskRunner::GetForThread(TID_IO); + // Currently on the FILE thread. + CefRefPtr 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_FALSE(CefCurrentlyOn(TID_UI)); + EXPECT_TRUE(CefCurrentlyOn(TID_DB)); + EXPECT_FALSE(CefCurrentlyOn(TID_FILE)); *got_it = true; } void PostTask2(bool* ran_test) { - // Currently on the UI thread. - EXPECT_FALSE(CefCurrentlyOn(TID_IO)); + // Currently on the FILE thread. + 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. - EXPECT_FALSE(CefCurrentlyOn(TID_IO)); + // Currently on the FILE thread. + 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))); - WaitForThread(TID_UI); + CefPostTask(TID_FILE, CefCreateClosureTask(base::Bind(&PostTask1, &ran_test))); + 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))); - WaitForThread(TID_UI); + CefPostTask(TID_FILE, CefCreateClosureTask(base::Bind(&PostTask2, &ran_test))); + 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); } diff --git a/tests/unittests/test_handler.cc b/tests/unittests/test_handler.cc index 296fa89ad..944b843db 100644 --- a/tests/unittests/test_handler.cc +++ b/tests/unittests/test_handler.cc @@ -99,9 +99,8 @@ class TestBrowserViewDelegate : public CefBrowserViewDelegate { TestHandler::CompletionState::CompletionState(int total) : total_(total), - count_(0), - event_(base::WaitableEvent::ResetPolicy::AUTOMATIC, - base::WaitableEvent::InitialState::NOT_SIGNALED) { + count_(0) { + event_ = CefWaitableEvent::CreateWaitableEvent(true, false); } 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(); } diff --git a/tests/unittests/test_handler.h b/tests/unittests/test_handler.h index 96fca1e15..8882b4d9a 100644 --- a/tests/unittests/test_handler.h +++ b/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 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 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 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 void ReleaseAndWaitForDestructor(CefRefPtr& handler, int delay_ms = 2000) { - base::WaitableEvent event( - base::WaitableEvent::ResetPolicy::AUTOMATIC, - base::WaitableEvent::InitialState::NOT_SIGNALED); - handler->SetDestroyEvent(&event); + CefRefPtr event = + CefWaitableEvent::CreateWaitableEvent(true, false); + handler->SetDestroyEvent(event); T* _handler_ptr = handler.get(); handler = NULL; - bool handler_destructed = - event.TimedWait(base::TimeDelta::FromMilliseconds(delay_ms)); + bool handler_destructed = event->TimedWait(delay_ms); EXPECT_TRUE(handler_destructed); if (!handler_destructed) { // |event| is a stack variable so clear the reference before returning. diff --git a/tests/unittests/thread_helper.cc b/tests/unittests/thread_helper.cc index 4084cf799..711858107 100644 --- a/tests/unittests/thread_helper.cc +++ b/tests/unittests/thread_helper.cc @@ -6,30 +6,28 @@ #include "include/wrapper/cef_closure_task.h" -void SignalEvent(base::WaitableEvent* event) { +void SignalEvent(CefRefPtr event) { event->Signal(); } void WaitForThread(CefThreadId thread_id, int64 delay_ms) { - base::WaitableEvent event( - base::WaitableEvent::ResetPolicy::AUTOMATIC, - base::WaitableEvent::InitialState::NOT_SIGNALED); - CefPostDelayedTask(thread_id, base::Bind(SignalEvent, &event), delay_ms); - event.Wait(); + CefRefPtr event = + CefWaitableEvent::CreateWaitableEvent(true, false); + CefPostDelayedTask(thread_id, base::Bind(SignalEvent, event), delay_ms); + event->Wait(); } void WaitForThread(CefRefPtr task_runner, int64 delay_ms) { - base::WaitableEvent event( - base::WaitableEvent::ResetPolicy::AUTOMATIC, - base::WaitableEvent::InitialState::NOT_SIGNALED); + CefRefPtr event = + CefWaitableEvent::CreateWaitableEvent(true, false); task_runner->PostDelayedTask( - CefCreateClosureTask(base::Bind(SignalEvent, &event)), delay_ms); - event.Wait(); + CefCreateClosureTask(base::Bind(SignalEvent, event)), delay_ms); + event->Wait(); } void RunOnThread(CefThreadId thread_id, const base::Callback& test_impl, - base::WaitableEvent* event) { + CefRefPtr 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& test_impl, - base::WaitableEvent* event) { + const base::Callback)>& test_impl, + CefRefPtr event) { if (!CefCurrentlyOn(thread_id)) { CefPostTask(thread_id, base::Bind(RunOnThreadAsync, thread_id, test_impl, event)); diff --git a/tests/unittests/thread_helper.h b/tests/unittests/thread_helper.h index 78c1b5a79..d7ac24eb8 100644 --- a/tests/unittests/thread_helper.h +++ b/tests/unittests/thread_helper.h @@ -8,11 +8,10 @@ #include "include/base/cef_bind.h" #include "include/cef_task.h" - -#include "base/synchronization/waitable_event.h" +#include "include/cef_waitable_event.h" // Helper for signaling |event|. -void SignalEvent(base::WaitableEvent* event); +void SignalEvent(CefRefPtr 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 task_runner, int64 delay_ms = 0); // once execution is complete. void RunOnThread(CefThreadId thread_id, const base::Callback& test_impl, - base::WaitableEvent* event); + CefRefPtr event); #define NAMED_THREAD_TEST(thread_id, test_case_name, test_name) \ TEST(test_case_name, test_name) { \ - base::WaitableEvent event( \ - base::WaitableEvent::ResetPolicy::AUTOMATIC, \ - base::WaitableEvent::InitialState::NOT_SIGNALED); \ - RunOnThread(thread_id, base::Bind(test_name##Impl), &event); \ - event.Wait(); \ + CefRefPtr event = \ + CefWaitableEvent::CreateWaitableEvent(true, false); \ + RunOnThread(thread_id, base::Bind(test_name##Impl), event); \ + 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& test_impl, - base::WaitableEvent* event); + const base::Callback)>& test_impl, + CefRefPtr); #define NAMED_THREAD_TEST_ASYNC(thread_id, test_case_name, test_name) \ TEST(test_case_name, test_name) { \ - base::WaitableEvent event( \ - base::WaitableEvent::ResetPolicy::AUTOMATIC, \ - base::WaitableEvent::InitialState::NOT_SIGNALED); \ - RunOnThreadAsync(thread_id, base::Bind(test_name##Impl), &event); \ - event.Wait(); \ + CefRefPtr event = \ + CefWaitableEvent::CreateWaitableEvent(true, false); \ + RunOnThreadAsync(thread_id, base::Bind(test_name##Impl), event); \ + 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 event)". #define UI_THREAD_TEST_ASYNC(test_case_name, test_name) \ NAMED_THREAD_TEST_ASYNC(TID_UI, test_case_name, test_name) diff --git a/tests/unittests/tracing_unittest.cc b/tests/unittests/tracing_unittest.cc index e702761e7..60a1572e0 100644 --- a/tests/unittests/tracing_unittest.cc +++ b/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, - base::WaitableEvent::InitialState::NOT_SIGNALED), - trace_type_(trace_type), + : 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 completion_event_; const char* trace_type_; TracingTestType type_; diff --git a/tests/unittests/urlrequest_unittest.cc b/tests/unittests/urlrequest_unittest.cc index e9721ad41..6fbce5850 100644 --- a/tests/unittests/urlrequest_unittest.cc +++ b/tests/unittests/urlrequest_unittest.cc @@ -5,12 +5,11 @@ #include #include -#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 request_context) { class Callback : public CefSetCookieCallback { public: - explicit Callback(base::WaitableEvent* event) + explicit Callback(CefRefPtr event) : event_(event) { EXPECT_TRUE(event_); } @@ -161,14 +160,13 @@ void SetTestCookie(CefRefPtr request_context) { } private: - base::WaitableEvent* event_; + CefRefPtr event_; IMPLEMENT_REFCOUNTING(Callback); }; - base::WaitableEvent event( - base::WaitableEvent::ResetPolicy::MANUAL, - base::WaitableEvent::InitialState::NOT_SIGNALED); + CefRefPtr event = + CefWaitableEvent::CreateWaitableEvent(false, false); CefCookie cookie; CefString(&cookie.name) = kRequestSendCookieName; @@ -177,11 +175,11 @@ void SetTestCookie(CefRefPtr 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)); - EXPECT_TRUE(event.IsSignaled()); + event->TimedWait(2000); + 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 request_context, class Visitor : public CefCookieVisitor { public: - Visitor(base::WaitableEvent* event, bool* cookie_exists) + Visitor(CefRefPtr event, bool* cookie_exists) : event_(event), cookie_exists_(cookie_exists) { EXPECT_TRUE(event_); @@ -213,24 +211,23 @@ void GetTestCookie(CefRefPtr request_context, } private: - base::WaitableEvent* event_; + CefRefPtr event_; bool* cookie_exists_; IMPLEMENT_REFCOUNTING(Visitor); }; - base::WaitableEvent event( - base::WaitableEvent::ResetPolicy::MANUAL, - base::WaitableEvent::InitialState::NOT_SIGNALED); + CefRefPtr event = + CefWaitableEvent::CreateWaitableEvent(false, false); CefRefPtr 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)); - EXPECT_TRUE(event.IsSignaled()); + event->TimedWait(2000); + EXPECT_TRUE(event->IsSignaled()); } @@ -1487,16 +1484,15 @@ namespace { class InvalidURLTestClient : public CefURLRequestClient { public: - InvalidURLTestClient() - : event_(base::WaitableEvent::ResetPolicy::AUTOMATIC, - base::WaitableEvent::InitialState::NOT_SIGNALED) { + InvalidURLTestClient() { + event_ = CefWaitableEvent::CreateWaitableEvent(true, false); } void RunTest() { CefPostTask(TID_UI, base::Bind(&InvalidURLTestClient::RunOnUIThread, this)); // Wait for the test to complete. - event_.Wait(); + event_->Wait(); } void OnRequestComplete(CefRefPtr 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 event_; IMPLEMENT_REFCOUNTING(InvalidURLTestClient); }; diff --git a/tests/unittests/views/button_unittest.cc b/tests/unittests/views/button_unittest.cc index 2a509accf..4866b2089 100644 --- a/tests/unittests/views/button_unittest.cc +++ b/tests/unittests/views/button_unittest.cc @@ -246,7 +246,7 @@ void RunLabelButtonClick(bool with_frame, kClickDelayMS); } -void LabelButtonClick(base::WaitableEvent* event, +void LabelButtonClick(CefRefPtr 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 event) { LabelButtonClick(event, true, true, true, true); } void LabelButtonClickFramedWithTextNoImageFramedWindowImpl( - base::WaitableEvent* event) { + CefRefPtr event) { LabelButtonClick(event, true, true, false, true); } void LabelButtonClickFramedWithTextWithImageFramelessWindowImpl( - base::WaitableEvent* event) { + CefRefPtr event) { LabelButtonClick(event, true, true, true, false); } void LabelButtonClickFramedWithTextNoImageFramelessWindowImpl( - base::WaitableEvent* event) { + CefRefPtr event) { LabelButtonClick(event, true, true, false, false); } void LabelButtonClickFramedNoTextWithImageFramedWindowImpl( - base::WaitableEvent* event) { + CefRefPtr event) { LabelButtonClick(event, true, false, true, true); } void LabelButtonClickFramedNoTextNoImageFramedWindowImpl( - base::WaitableEvent* event) { + CefRefPtr event) { LabelButtonClick(event, true, false, false, true); } void LabelButtonClickFramedNoTextWithImageFramelessWindowImpl( - base::WaitableEvent* event) { + CefRefPtr event) { LabelButtonClick(event, true, false, true, false); } void LabelButtonClickFramedNoTextNoImageFramelessWindowImpl( - base::WaitableEvent* event) { + CefRefPtr event) { LabelButtonClick(event, true, false, false, false); } void LabelButtonClickFramelessWithTextWithImageFramedWindowImpl( - base::WaitableEvent* event) { + CefRefPtr event) { LabelButtonClick(event, false, true, true, true); } void LabelButtonClickFramelessWithTextNoImageFramedWindowImpl( - base::WaitableEvent* event) { + CefRefPtr event) { LabelButtonClick(event, false, true, false, true); } void LabelButtonClickFramelessWithTextWithImageFramelessWindowImpl( - base::WaitableEvent* event) { + CefRefPtr event) { LabelButtonClick(event, false, true, true, false); } void LabelButtonClickFramelessWithTextNoImageFramelessWindowImpl( - base::WaitableEvent* event) { + CefRefPtr event) { LabelButtonClick(event, false, true, false, false); } void LabelButtonClickFramelessNoTextWithImageFramedWindowImpl( - base::WaitableEvent* event) { + CefRefPtr event) { LabelButtonClick(event, false, false, true, true); } void LabelButtonClickFramelessNoTextNoImageFramedWindowImpl( - base::WaitableEvent* event) { + CefRefPtr event) { LabelButtonClick(event, false, false, false, true); } void LabelButtonClickFramelessNoTextWithImageFramelessWindowImpl( - base::WaitableEvent* event) { + CefRefPtr event) { LabelButtonClick(event, false, false, true, false); } void LabelButtonClickFramelessNoTextNoImageFramelessWindowImpl( - base::WaitableEvent* event) { + CefRefPtr 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 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 event) { MenuButtonClick(event, true, true, true, true, true); } void MenuButtonClickFramedWithTextNoMarkerWithImageFramedWindowImpl( - base::WaitableEvent* event) { + CefRefPtr event) { MenuButtonClick(event, true, true, false, true, true); } void MenuButtonClickFramedWithTextWithMarkerNoImageFramedWindowImpl( - base::WaitableEvent* event) { + CefRefPtr event) { MenuButtonClick(event, true, true, true, false, true); } void MenuButtonClickFramedWithTextNoMarkerNoImageFramedWindowImpl( - base::WaitableEvent* event) { + CefRefPtr event) { MenuButtonClick(event, true, true, false, false, true); } void MenuButtonClickFramedWithTextWithMarkerWithImageFramelessWindowImpl( - base::WaitableEvent* event) { + CefRefPtr event) { MenuButtonClick(event, true, true, true, true, false); } void MenuButtonClickFramedWithTextNoMarkerWithImageFramelessWindowImpl( - base::WaitableEvent* event) { + CefRefPtr event) { MenuButtonClick(event, true, true, false, true, false); } void MenuButtonClickFramedWithTextWithMarkerNoImageFramelessWindowImpl( - base::WaitableEvent* event) { + CefRefPtr event) { MenuButtonClick(event, true, true, true, false, false); } void MenuButtonClickFramedWithTextNoMarkerNoImageFramelessWindowImpl( - base::WaitableEvent* event) { + CefRefPtr event) { MenuButtonClick(event, true, true, false, false, false); } void MenuButtonClickFramedNoTextWithMarkerWithImageFramedWindowImpl( - base::WaitableEvent* event) { + CefRefPtr event) { MenuButtonClick(event, true, false, true, true, true); } void MenuButtonClickFramedNoTextNoMarkerWithImageFramedWindowImpl( - base::WaitableEvent* event) { + CefRefPtr event) { MenuButtonClick(event, true, false, false, true, true); } void MenuButtonClickFramedNoTextWithMarkerNoImageFramedWindowImpl( - base::WaitableEvent* event) { + CefRefPtr event) { MenuButtonClick(event, true, false, true, false, true); } void MenuButtonClickFramedNoTextNoMarkerNoImageFramedWindowImpl( - base::WaitableEvent* event) { + CefRefPtr event) { MenuButtonClick(event, true, false, false, false, true); } void MenuButtonClickFramedNoTextWithMarkerWithImageFramelessWindowImpl( - base::WaitableEvent* event) { + CefRefPtr event) { MenuButtonClick(event, true, false, true, true, false); } void MenuButtonClickFramedNoTextNoMarkerWithImageFramelessWindowImpl( - base::WaitableEvent* event) { + CefRefPtr event) { MenuButtonClick(event, true, false, false, true, false); } void MenuButtonClickFramedNoTextWithMarkerNoImageFramelessWindowImpl( - base::WaitableEvent* event) { + CefRefPtr event) { MenuButtonClick(event, true, false, true, false, false); } void MenuButtonClickFramedNoTextNoMarkerNoImageFramelessWindowImpl( - base::WaitableEvent* event) { + CefRefPtr event) { MenuButtonClick(event, true, false, false, false, false); } void MenuButtonClickFramelessWithTextWithMarkerWithImageFramedWindowImpl( - base::WaitableEvent* event) { + CefRefPtr event) { MenuButtonClick(event, false, true, true, true, true); } void MenuButtonClickFramelessWithTextNoMarkerWithImageFramedWindowImpl( - base::WaitableEvent* event) { + CefRefPtr event) { MenuButtonClick(event, false, true, false, true, true); } void MenuButtonClickFramelessWithTextWithMarkerNoImageFramedWindowImpl( - base::WaitableEvent* event) { + CefRefPtr event) { MenuButtonClick(event, false, true, true, false, true); } void MenuButtonClickFramelessWithTextNoMarkerNoImageFramedWindowImpl( - base::WaitableEvent* event) { + CefRefPtr event) { MenuButtonClick(event, false, true, false, false, true); } void MenuButtonClickFramelessWithTextWithMarkerWithImageFramelessWindowImpl( - base::WaitableEvent* event) { + CefRefPtr event) { MenuButtonClick(event, false, true, true, true, false); } void MenuButtonClickFramelessWithTextNoMarkerWithImageFramelessWindowImpl( - base::WaitableEvent* event) { + CefRefPtr event) { MenuButtonClick(event, false, true, false, true, false); } void MenuButtonClickFramelessWithTextWithMarkerNoImageFramelessWindowImpl( - base::WaitableEvent* event) { + CefRefPtr event) { MenuButtonClick(event, false, true, true, false, false); } void MenuButtonClickFramelessWithTextNoMarkerNoImageFramelessWindowImpl( - base::WaitableEvent* event) { + CefRefPtr event) { MenuButtonClick(event, false, true, false, false, false); } void MenuButtonClickFramelessNoTextWithMarkerWithImageFramedWindowImpl( - base::WaitableEvent* event) { + CefRefPtr event) { MenuButtonClick(event, false, false, true, true, true); } void MenuButtonClickFramelessNoTextNoMarkerWithImageFramedWindowImpl( - base::WaitableEvent* event) { + CefRefPtr event) { MenuButtonClick(event, false, false, false, true, true); } void MenuButtonClickFramelessNoTextWithMarkerNoImageFramedWindowImpl( - base::WaitableEvent* event) { + CefRefPtr event) { MenuButtonClick(event, false, false, true, false, true); } void MenuButtonClickFramelessNoTextNoMarkerNoImageFramedWindowImpl( - base::WaitableEvent* event) { + CefRefPtr event) { MenuButtonClick(event, false, false, false, false, true); } void MenuButtonClickFramelessNoTextWithMarkerWithImageFramelessWindowImpl( - base::WaitableEvent* event) { + CefRefPtr event) { MenuButtonClick(event, false, false, true, true, false); } void MenuButtonClickFramelessNoTextNoMarkerWithImageFramelessWindowImpl( - base::WaitableEvent* event) { + CefRefPtr event) { MenuButtonClick(event, false, false, false, true, false); } void MenuButtonClickFramelessNoTextWithMarkerNoImageFramelessWindowImpl( - base::WaitableEvent* event) { + CefRefPtr event) { MenuButtonClick(event, false, false, true, false, false); } void MenuButtonClickFramelessNoTextNoMarkerNoImageFramelessWindowImpl( - base::WaitableEvent* event) { + CefRefPtr event) { MenuButtonClick(event, false, false, false, false, false); } diff --git a/tests/unittests/views/scroll_view_unittest.cc b/tests/unittests/views/scroll_view_unittest.cc index a9c62528c..a2f0923ea 100644 --- a/tests/unittests/views/scroll_view_unittest.cc +++ b/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 event, bool with_delegate) { TestWindowDelegate::RunTest(event, base::Bind(RunScrollViewLayout, with_delegate), false); } -void ScrollViewLayoutWithDelegateImpl(base::WaitableEvent* event) { +void ScrollViewLayoutWithDelegateImpl(CefRefPtr event) { ScrollViewLayout(event, true); } -void ScrollViewLayoutNoDelegateImpl(base::WaitableEvent* event) { +void ScrollViewLayoutNoDelegateImpl(CefRefPtr event) { ScrollViewLayout(event, false); } diff --git a/tests/unittests/views/test_window_delegate.cc b/tests/unittests/views/test_window_delegate.cc index 6df216ff7..ac2697df0 100644 --- a/tests/unittests/views/test_window_delegate.cc +++ b/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 event, const WindowTest& window_test, bool frameless, bool close_window, @@ -113,7 +113,7 @@ CefSize TestWindowDelegate::GetPreferredSize(CefRefPtr view) { return CefSize(window_size_, window_size_); } -TestWindowDelegate::TestWindowDelegate(base::WaitableEvent* event, +TestWindowDelegate::TestWindowDelegate(CefRefPtr event, const WindowTest& window_test, bool frameless, bool close_window, diff --git a/tests/unittests/views/test_window_delegate.h b/tests/unittests/views/test_window_delegate.h index 8d55f10eb..6cdded62e 100644 --- a/tests/unittests/views/test_window_delegate.h +++ b/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 event, const WindowTest& window_test, bool frameless = false, bool close_window = true, @@ -36,7 +36,7 @@ class TestWindowDelegate : public CefWindowDelegate { CefSize GetPreferredSize(CefRefPtr view) override; private: - TestWindowDelegate(base::WaitableEvent* event, + TestWindowDelegate(CefRefPtr 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 event_; WindowTest window_test_; bool frameless_; bool close_window_; diff --git a/tests/unittests/views/textfield_unittest.cc b/tests/unittests/views/textfield_unittest.cc index fe4ac30e5..6f2a35292 100644 --- a/tests/unittests/views/textfield_unittest.cc +++ b/tests/unittests/views/textfield_unittest.cc @@ -265,7 +265,7 @@ void RunTextfieldKeyEvent(CefRefPtr window) { window->SendKeyPress(ui::VKEY_RETURN, 0); } -void TextfieldKeyEventImpl(base::WaitableEvent* event) { +void TextfieldKeyEventImpl(CefRefPtr event) { TestWindowDelegate::RunTest(event, base::Bind(RunTextfieldKeyEvent), false, false); } diff --git a/tests/unittests/views/window_unittest.cc b/tests/unittests/views/window_unittest.cc index df2f66885..a347a470e 100644 --- a/tests/unittests/views/window_unittest.cc +++ b/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 event) { TestWindowDelegate::RunTest(event, TestWindowDelegate::WindowTest(), false); } -void WindowCreateFramelessImpl(base::WaitableEvent* event) { +void WindowCreateFramelessImpl(CefRefPtr event) { TestWindowDelegate::RunTest(event, TestWindowDelegate::WindowTest(), true); } @@ -52,11 +52,11 @@ void RunWindowShowHide(CefRefPtr window) { EXPECT_FALSE(window->IsDrawn()); } -void WindowShowHideImpl(base::WaitableEvent* event) { +void WindowShowHideImpl(CefRefPtr event) { TestWindowDelegate::RunTest(event, base::Bind(RunWindowShowHide), false); } -void WindowShowHideFramelessImpl(base::WaitableEvent* event) { +void WindowShowHideFramelessImpl(CefRefPtr event) { TestWindowDelegate::RunTest(event, base::Bind(RunWindowShowHide), true); } @@ -180,11 +180,11 @@ void RunWindowLayoutAndCoords(CefRefPtr window) { point); } -void WindowLayoutAndCoordsImpl(base::WaitableEvent* event) { +void WindowLayoutAndCoordsImpl(CefRefPtr event) { TestWindowDelegate::RunTest(event, base::Bind(RunWindowLayoutAndCoords), false); } -void WindowLayoutAndCoordsFramelessImpl(base::WaitableEvent* event) { +void WindowLayoutAndCoordsFramelessImpl(CefRefPtr event) { TestWindowDelegate::RunTest(event, base::Bind(RunWindowLayoutAndCoords), true); } @@ -223,12 +223,12 @@ void RunWindowMaximize(CefRefPtr window) { CefPostDelayedTask(TID_UI, base::Bind(VerifyMaximize, window), kStateDelayMS); } -void WindowMaximizeImpl(base::WaitableEvent* event) { +void WindowMaximizeImpl(CefRefPtr event) { TestWindowDelegate::RunTest(event, base::Bind(RunWindowMaximize), false, false); } -void WindowMaximizeFramelessImpl(base::WaitableEvent* event) { +void WindowMaximizeFramelessImpl(CefRefPtr event) { TestWindowDelegate::RunTest(event, base::Bind(RunWindowMaximize), true, false); } @@ -260,12 +260,12 @@ void RunWindowMinimize(CefRefPtr window) { CefPostDelayedTask(TID_UI, base::Bind(VerifyMinimize, window), kStateDelayMS); } -void WindowMinimizeImpl(base::WaitableEvent* event) { +void WindowMinimizeImpl(CefRefPtr event) { TestWindowDelegate::RunTest(event, base::Bind(RunWindowMinimize), false, false); } -void WindowMinimizeFramelessImpl(base::WaitableEvent* event) { +void WindowMinimizeFramelessImpl(CefRefPtr event) { TestWindowDelegate::RunTest(event, base::Bind(RunWindowMinimize), true, false); } @@ -307,12 +307,12 @@ void RunWindowFullscreen(CefRefPtr window) { kStateDelayMS); } -void WindowFullscreenImpl(base::WaitableEvent* event) { +void WindowFullscreenImpl(CefRefPtr event) { TestWindowDelegate::RunTest(event, base::Bind(RunWindowFullscreen), false, false); } -void WindowFullscreenFramelessImpl(base::WaitableEvent* event) { +void WindowFullscreenFramelessImpl(CefRefPtr event) { TestWindowDelegate::RunTest(event, base::Bind(RunWindowFullscreen), true, false); } @@ -333,11 +333,11 @@ void RunWindowIcon(CefRefPtr window) { window->Show(); } -void WindowIconImpl(base::WaitableEvent* event) { +void WindowIconImpl(CefRefPtr event) { TestWindowDelegate::RunTest(event, base::Bind(RunWindowIcon), false); } -void WindowIconFramelessImpl(base::WaitableEvent* event) { +void WindowIconFramelessImpl(CefRefPtr event) { TestWindowDelegate::RunTest(event, base::Bind(RunWindowIcon), true); } diff --git a/tests/unittests/waitable_event_unittest.cc b/tests/unittests/waitable_event_unittest.cc new file mode 100644 index 000000000..9373febe6 --- /dev/null +++ b/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 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 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 event = + CefWaitableEvent::CreateWaitableEvent(true, false); + + CefRefPtr 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; +}