bcarrella/cef
1
0
Fork 0
mirror of https://bitbucket.org/chromiumembedded/cef synced 2025-02-10 00:50:38 +01:00
Code Issues Packages Projects Releases Wiki Activity

Add CefWaitableEvent interface for unit tests (issue #1632)

Browse Source
This commit is contained in:
Marshall Greenblatt 2016-11-15 16:18:41 -05:00
parent 9c76128317
commit ac9d105c5d
30 changed files with 1173 additions and 429 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
BUILD.gn
View File

@ -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",

6
cef_paths.gypi
View File

@ -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',

117
include/capi/cef_waitable_event_capi.h Normal file
View File

@ -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_

109
include/cef_waitable_event.h Normal file
View File

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

60
libcef/common/waitable_event_impl.cc Normal file
View File

@ -0,0 +1,60 @@
// Copyright 2016 The Chromium Embedded Framework Authors. All rights
// reserved. Use of this source code is governed by a BSD-style license that can
// be found in the LICENSE file.
#include "libcef/common/waitable_event_impl.h"
#include "include/cef_task.h"
#include "base/time/time.h"
namespace {
bool AllowWait() {
if (CefCurrentlyOn(TID_UI) || CefCurrentlyOn(TID_IO)) {
NOTREACHED() << "waiting is not allowed on the current thread";
return false;
}
return true;
}
} // namespace
// static
CefRefPtr<CefWaitableEvent> CefWaitableEvent::CreateWaitableEvent(
bool automatic_reset,
bool initially_signaled) {
return new CefWaitableEventImpl(automatic_reset, initially_signaled);
}
CefWaitableEventImpl::CefWaitableEventImpl(bool automatic_reset,
bool initially_signaled)
: event_(automatic_reset ? base::WaitableEvent::ResetPolicy::AUTOMATIC :
base::WaitableEvent::ResetPolicy::MANUAL,
initially_signaled ? base::WaitableEvent::InitialState::SIGNALED :
base::WaitableEvent::InitialState::NOT_SIGNALED) {
}
void CefWaitableEventImpl::Reset() {
event_.Reset();
}
void CefWaitableEventImpl::Signal() {
event_.Signal();
}
bool CefWaitableEventImpl::IsSignaled() {
return event_.IsSignaled();
}
void CefWaitableEventImpl::Wait() {
if (!AllowWait())
return;
event_.Wait();
}
bool CefWaitableEventImpl::TimedWait(int64 max_ms) {
if (!AllowWait())
return false;
return event_.TimedWait(base::TimeDelta::FromMilliseconds(max_ms));
}

31
libcef/common/waitable_event_impl.h Normal file
View File

@ -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_

126
libcef_dll/cpptoc/waitable_event_cpptoc.cc Normal file
View File

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

35
libcef_dll/cpptoc/waitable_event_cpptoc.h Normal file
View File

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

115
libcef_dll/ctocpp/waitable_event_ctocpp.cc Normal file
View File

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

42
libcef_dll/ctocpp/waitable_event_ctocpp.h Normal file
View File

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

2
libcef_dll/libcef_dll.cc
View File

@ -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));

2
libcef_dll/wrapper/libcef_dll_wrapper.cc
View File

@ -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));

1
libcef_dll/wrapper_types.h
View File

@ -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,

356
tests/unittests/cookie_unittest.cc
View File

@ -4,13 +4,12 @@
#include <vector>
#include "base/synchronization/waitable_event.h"
#include "include/base/cef_bind.h"
#include "include/base/cef_logging.h"
#include "include/base/cef_ref_counted.h"
#include "include/cef_cookie.h"
#include "include/cef_scheme.h"
#include "include/cef_waitable_event.h"
#include "include/wrapper/cef_closure_task.h"
#include "include/wrapper/cef_scoped_temp_dir.h"
#include "testing/gtest/include/gtest/gtest.h"
@ -31,7 +30,7 @@ typedef std::vector<CefCookie> CookieVector;
class TestCompletionCallback : public CefCompletionCallback {
public:
explicit TestCompletionCallback(base::WaitableEvent* event)
explicit TestCompletionCallback(CefRefPtr<CefWaitableEvent> event)
: event_(event) {}
void OnComplete() override {
@ -39,7 +38,7 @@ class TestCompletionCallback : public CefCompletionCallback {
}
private:
base::WaitableEvent* event_;
CefRefPtr<CefWaitableEvent> event_;
IMPLEMENT_REFCOUNTING(TestCompletionCallback);
DISALLOW_COPY_AND_ASSIGN(TestCompletionCallback);
@ -48,7 +47,7 @@ class TestCompletionCallback : public CefCompletionCallback {
class TestSetCookieCallback : public CefSetCookieCallback {
public:
TestSetCookieCallback(bool expected_success,
base::WaitableEvent* event)
CefRefPtr<CefWaitableEvent> event)
: expected_success_(expected_success),
event_(event) {}
@ -59,7 +58,7 @@ class TestSetCookieCallback : public CefSetCookieCallback {
private:
bool expected_success_;
base::WaitableEvent* event_;
CefRefPtr<CefWaitableEvent> event_;
IMPLEMENT_REFCOUNTING(TestSetCookieCallback);
DISALLOW_COPY_AND_ASSIGN(TestSetCookieCallback);
@ -68,7 +67,7 @@ class TestSetCookieCallback : public CefSetCookieCallback {
class TestDeleteCookiesCallback : public CefDeleteCookiesCallback {
public:
TestDeleteCookiesCallback(int expected_num_deleted,
base::WaitableEvent* event)
CefRefPtr<CefWaitableEvent> event)
: expected_num_deleted_(expected_num_deleted),
event_(event) {}
@ -80,7 +79,7 @@ class TestDeleteCookiesCallback : public CefDeleteCookiesCallback {
private:
int expected_num_deleted_;
base::WaitableEvent* event_;
CefRefPtr<CefWaitableEvent> event_;
IMPLEMENT_REFCOUNTING(TestDeleteCookiesCallback);
DISALLOW_COPY_AND_ASSIGN(TestDeleteCookiesCallback);
@ -89,7 +88,7 @@ class TestDeleteCookiesCallback : public CefDeleteCookiesCallback {
class TestVisitor : public CefCookieVisitor {
public:
TestVisitor(CookieVector* cookies, bool deleteCookies,
base::WaitableEvent* event)
CefRefPtr<CefWaitableEvent> event)
: cookies_(cookies),
delete_cookies_(deleteCookies),
event_(event) {
@ -108,7 +107,7 @@ class TestVisitor : public CefCookieVisitor {
CookieVector* cookies_;
bool delete_cookies_;
base::WaitableEvent* event_;
CefRefPtr<CefWaitableEvent> event_;
IMPLEMENT_REFCOUNTING(TestVisitor);
};
@ -117,12 +116,12 @@ class TestVisitor : public CefCookieVisitor {
void SetCookies(CefRefPtr<CefCookieManager> manager,
const CefString& url, const CookieVector& cookies,
bool expected_success,
base::WaitableEvent& event) {
CefRefPtr<CefWaitableEvent> event) {
CookieVector::const_iterator it = cookies.begin();
for (; it != cookies.end(); ++it) {
EXPECT_TRUE(manager->SetCookie(
url, *it, new TestSetCookieCallback(expected_success, &event)));
event.Wait();
url, *it, new TestSetCookieCallback(expected_success, event)));
event->Wait();
}
}
@ -130,11 +129,11 @@ void SetCookies(CefRefPtr<CefCookieManager> manager,
void DeleteCookies(CefRefPtr<CefCookieManager> manager,
const CefString& url, const CefString& cookie_name,
int expected_num_deleted,
base::WaitableEvent& event) {
CefRefPtr<CefWaitableEvent> event) {
EXPECT_TRUE(manager->DeleteCookies(
url, cookie_name,
new TestDeleteCookiesCallback(expected_num_deleted, &event)));
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<CefCookieManager> manager,
void CreateCookie(CefRefPtr<CefCookieManager> manager,
CefCookie& cookie, bool withDomain,
bool sessionCookie,
base::WaitableEvent& event) {
CefRefPtr<CefWaitableEvent> event) {
CefString(&cookie.name).FromASCII("my_cookie");
CefString(&cookie.value).FromASCII("My Value");
if (withDomain)
@ -167,13 +166,13 @@ void CreateCookie(CefRefPtr<CefCookieManager> manager,
// the cookie will be deleted when it's retrieved.
void GetCookie(CefRefPtr<CefCookieManager> manager,
const CefCookie& cookie, bool withDomain,
base::WaitableEvent& event, bool deleteCookies) {
CefRefPtr<CefWaitableEvent> event, bool deleteCookies) {
CookieVector cookies;
// Get the cookie and delete it.
EXPECT_TRUE(manager->VisitUrlCookies(kTestUrl, false,
new TestVisitor(&cookies, deleteCookies, &event)));
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<CefCookieManager> manager,
bool includeHttpOnly,
CookieVector& cookies,
bool deleteCookies,
base::WaitableEvent& event) {
CefRefPtr<CefWaitableEvent> event) {
EXPECT_TRUE(manager->VisitUrlCookies(url, includeHttpOnly,
new TestVisitor(&cookies, deleteCookies, &event)));
event.Wait();
new TestVisitor(&cookies, deleteCookies, event)));
event->Wait();
}
// Visit all cookies.
void VisitAllCookies(CefRefPtr<CefCookieManager> manager,
CookieVector& cookies,
bool deleteCookies,
base::WaitableEvent& event) {
CefRefPtr<CefWaitableEvent> event) {
EXPECT_TRUE(manager->VisitAllCookies(
new TestVisitor(&cookies, deleteCookies, &event)));
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<CefCookieManager> manager,
base::WaitableEvent& event, bool withUrl) {
CefRefPtr<CefWaitableEvent> event, bool withUrl) {
CookieVector cookies;
// Verify that the cookie has been deleted.
if (withUrl) {
EXPECT_TRUE(manager->VisitUrlCookies(kTestUrl, false,
new TestVisitor(&cookies, false, &event)));
new TestVisitor(&cookies, false, event)));
} else {
EXPECT_TRUE(manager->VisitAllCookies(
new TestVisitor(&cookies, false, &event)));
new TestVisitor(&cookies, false, event)));
}
event.Wait();
event->Wait();
EXPECT_EQ(0U, cookies.size());
}
// Delete all system cookies.
void DeleteAllCookies(CefRefPtr<CefCookieManager> manager,
base::WaitableEvent& event) {
CefRefPtr<CefWaitableEvent> event) {
DeleteCookies(manager, CefString(), CefString(), kIgnoreNumDeleted, event);
}
void TestDomainCookie(CefRefPtr<CefCookieManager> manager,
base::WaitableEvent& event) {
CefRefPtr<CefWaitableEvent> event) {
CefCookie cookie;
// Create a domain cookie.
@ -260,7 +259,7 @@ void TestDomainCookie(CefRefPtr<CefCookieManager> manager,
}
void TestHostCookie(CefRefPtr<CefCookieManager> manager,
base::WaitableEvent& event) {
CefRefPtr<CefWaitableEvent> event) {
CefCookie cookie;
// Create a host cookie.
@ -274,7 +273,7 @@ void TestHostCookie(CefRefPtr<CefCookieManager> manager,
}
void TestMultipleCookies(CefRefPtr<CefCookieManager> manager,
base::WaitableEvent& event) {
CefRefPtr<CefWaitableEvent> event) {
std::stringstream ss;
int i;
@ -369,7 +368,7 @@ void TestMultipleCookies(CefRefPtr<CefCookieManager> manager,
}
void TestAllCookies(CefRefPtr<CefCookieManager> manager,
base::WaitableEvent& event) {
CefRefPtr<CefWaitableEvent> event) {
CookieVector cookies;
// Delete all system cookies just in case something is left over from a
@ -446,7 +445,7 @@ void TestAllCookies(CefRefPtr<CefCookieManager> manager,
}
void TestChangeDirectory(CefRefPtr<CefCookieManager> manager,
base::WaitableEvent& event,
CefRefPtr<CefWaitableEvent> event,
const CefString& original_dir) {
CefCookie cookie;
@ -502,13 +501,12 @@ void TestChangeDirectory(CefRefPtr<CefCookieManager> manager,
// Test creation of a domain cookie.
TEST(CookieTest, DomainCookieGlobal) {
base::WaitableEvent event(
base::WaitableEvent::ResetPolicy::AUTOMATIC,
base::WaitableEvent::InitialState::NOT_SIGNALED);
CefRefPtr<CefWaitableEvent> event =
CefWaitableEvent::CreateWaitableEvent(true, false);
CefRefPtr<CefCookieManager> 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<CefWaitableEvent> event =
CefWaitableEvent::CreateWaitableEvent(true, false);
CefRefPtr<CefCookieManager> 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<CefWaitableEvent> event =
CefWaitableEvent::CreateWaitableEvent(true, false);
CefRefPtr<CefCookieManager> 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<CefWaitableEvent> event =
CefWaitableEvent::CreateWaitableEvent(true, false);
CefRefPtr<CefCookieManager> 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<CefWaitableEvent> event =
CefWaitableEvent::CreateWaitableEvent(true, false);
CefRefPtr<CefCookieManager> 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<CefWaitableEvent> event =
CefWaitableEvent::CreateWaitableEvent(true, false);
CefRefPtr<CefCookieManager> 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<CefWaitableEvent> event =
CefWaitableEvent::CreateWaitableEvent(true, false);
CefRefPtr<CefCookieManager> 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<CefWaitableEvent> event =
CefWaitableEvent::CreateWaitableEvent(true, false);
CefRefPtr<CefCookieManager> 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<CefWaitableEvent> event =
CefWaitableEvent::CreateWaitableEvent(true, false);
CefRefPtr<CefCookieManager> 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<CefWaitableEvent> event =
CefWaitableEvent::CreateWaitableEvent(true, false);
CefRefPtr<CefCookieManager> 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<CefWaitableEvent> event =
CefWaitableEvent::CreateWaitableEvent(true, false);
CefRefPtr<CefCookieManager> 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<CefWaitableEvent> event =
CefWaitableEvent::CreateWaitableEvent(true, false);
CefRefPtr<CefCookieManager> 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<CefWaitableEvent> event =
CefWaitableEvent::CreateWaitableEvent(true, false);
CefRefPtr<CefCookieManager> 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<CefWaitableEvent> event =
CefWaitableEvent::CreateWaitableEvent(true, false);
CefRefPtr<CefCookieManager> 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<CefWaitableEvent> event =
CefWaitableEvent::CreateWaitableEvent(true, false);
CefCookie cookie;
// Create a new temporary directory.
@ -755,8 +739,8 @@ TEST(CookieTest, SessionCookieNoPersist) {
CefRefPtr<CefCookieManager> manager =
CefCookieManager::CreateManager(temp_dir.GetPath(), false,
new TestCompletionCallback(&event));
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<CefWaitableEvent> event =
CefWaitableEvent::CreateWaitableEvent(true, false);
CefCookie cookie;
// Create a new temporary directory.
@ -791,8 +774,8 @@ TEST(CookieTest, SessionCookieWillPersist) {
CefRefPtr<CefCookieManager> manager =
CefCookieManager::CreateManager(temp_dir.GetPath(), true,
new TestCompletionCallback(&event));
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<CefFrame> frame) {
if (!CefCurrentlyOn(TID_UI)) {
CefPostTask(TID_UI,
base::Bind(&CookieTestJSHandler::LoadNextURL, this, frame));
return;
}
context_handler_->SetURL(kCookieJSUrl2);
frame->LoadURL(kCookieJSUrl2);
}
void CompleteTest() {
if (!CefCurrentlyOn(TID_UI)) {
CefPostTask(TID_UI,
base::Bind(&CookieTestJSHandler::CompleteTest, this));
return;
}
DestroyTest();
}
void OnLoadEnd(CefRefPtr<CefBrowser> browser,
CefRefPtr<CefFrame> frame,
int httpStatusCode) override {
std::string url = frame->GetURL();
if (url == kCookieJSUrl1) {
got_load_end1_.yes();
VerifyCookie(manager1_, url, "name1", "value1", got_cookie1_);
// 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<CefWaitableEvent> event =
CefWaitableEvent::CreateWaitableEvent(true, false);
CookieVector cookies;
// Get the cookie.
@ -938,8 +947,10 @@ class CookieTestJSHandler : public TestHandler {
if (cookies.size() == 1U && CefString(&cookies[0].name) == name &&
CefString(&cookies[0].value) == value) {
callback.yes();
callback->yes();
}
continue_callback.Run();
}
CefRefPtr<RequestContextHandler> context_handler_;
@ -1163,33 +1174,50 @@ class CookieTestSchemeHandler : public TestHandler {
SetTestTimeout();
}
// Go to the next URL.
void LoadNextURL(CefRefPtr<CefFrame> 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<CefBrowser> 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<CefBrowser> browser,
CefRefPtr<CefFrame> frame,
int httpStatusCode) override {
std::string url = frame->GetURL();
if (url == url1_) {
got_load_end1_.yes();
VerifyCookie(manager1_, url, "name1", "value1", got_cookie1_);
// 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<CefWaitableEvent> event =
CefWaitableEvent::CreateWaitableEvent(true, false);
CookieVector cookies;
// Get the cookie.
@ -1216,8 +1252,10 @@ class CookieTestSchemeHandler : public TestHandler {
if (cookies.size() == 1U && CefString(&cookies[0].name) == name &&
CefString(&cookies[0].value) == value) {
callback.yes();
callback->yes();
}
continue_callback.Run();
}
std::string scheme_;

16
tests/unittests/geolocation_unittest.cc
View File

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

103
tests/unittests/preference_unittest.cc
View File

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

106
tests/unittests/task_unittest.cc
View File

@ -11,12 +11,12 @@
namespace {
void GetForCurrentThread(bool* ran_test) {
// Currently on the UI thread.
// Currently on the FILE thread.
CefRefPtr<CefTaskRunner> runner = CefTaskRunner::GetForCurrentThread();
EXPECT_TRUE(runner.get());
EXPECT_TRUE(runner->BelongsToCurrentThread());
EXPECT_TRUE(runner->BelongsToThread(TID_UI));
EXPECT_FALSE(runner->BelongsToThread(TID_IO));
EXPECT_TRUE(runner->BelongsToThread(TID_FILE));
EXPECT_FALSE(runner->BelongsToThread(TID_DB));
EXPECT_TRUE(runner->IsSame(runner));
CefRefPtr<CefTaskRunner> runner2 = CefTaskRunner::GetForCurrentThread();
@ -24,8 +24,8 @@ void GetForCurrentThread(bool* ran_test) {
EXPECT_TRUE(runner->IsSame(runner2));
EXPECT_TRUE(runner2->IsSame(runner));
// Not on the IO thread.
CefRefPtr<CefTaskRunner> runner3 = CefTaskRunner::GetForThread(TID_IO);
// Not on the DB thread.
CefRefPtr<CefTaskRunner> runner3 = CefTaskRunner::GetForThread(TID_DB);
EXPECT_TRUE(runner3.get());
EXPECT_FALSE(runner->IsSame(runner3));
EXPECT_FALSE(runner3->IsSame(runner));
@ -34,20 +34,20 @@ void GetForCurrentThread(bool* ran_test) {
}
void GetForThread(bool* ran_test) {
// Currently on the UI thread.
CefRefPtr<CefTaskRunner> runner = CefTaskRunner::GetForThread(TID_IO);
// Currently on the FILE thread.
CefRefPtr<CefTaskRunner> 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<CefTaskRunner> runner2 = CefTaskRunner::GetForThread(TID_IO);
CefRefPtr<CefTaskRunner> runner2 = CefTaskRunner::GetForThread(TID_DB);
EXPECT_TRUE(runner2.get());
EXPECT_TRUE(runner->IsSame(runner2));
EXPECT_TRUE(runner2->IsSame(runner));
CefRefPtr<CefTaskRunner> runner3 = CefTaskRunner::GetForThread(TID_UI);
CefRefPtr<CefTaskRunner> runner3 = CefTaskRunner::GetForThread(TID_FILE);
EXPECT_TRUE(runner3.get());
EXPECT_FALSE(runner->IsSame(runner3));
EXPECT_FALSE(runner3->IsSame(runner));
@ -56,35 +56,35 @@ void GetForThread(bool* ran_test) {
}
void PostTaskEvent1(bool* got_it, CefRefPtr<CefTaskRunner> runner) {
// Currently on the IO thread.
// Currently on the DB thread.
EXPECT_TRUE(runner->BelongsToCurrentThread());
EXPECT_TRUE(runner->BelongsToThread(TID_IO));
EXPECT_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<CefTaskRunner> 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<CefTaskRunner> runner3 = CefTaskRunner::GetForThread(TID_IO);
// Current thread should be the DB thread.
CefRefPtr<CefTaskRunner> 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<CefTaskRunner> runner4 = CefTaskRunner::GetForThread(TID_UI);
// Current thread should not be the FILE thread.
CefRefPtr<CefTaskRunner> 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<CefTaskRunner> runner) {
}
void PostTask1(bool* ran_test) {
// Currently on the UI thread.
CefRefPtr<CefTaskRunner> runner = CefTaskRunner::GetForThread(TID_IO);
// Currently on the FILE thread.
CefRefPtr<CefTaskRunner> runner = CefTaskRunner::GetForThread(TID_DB);
EXPECT_TRUE(runner.get());
EXPECT_FALSE(runner->BelongsToCurrentThread());
EXPECT_TRUE(runner->BelongsToThread(TID_IO));
EXPECT_TRUE(runner->BelongsToThread(TID_DB));
bool got_it = false;
runner->PostTask(
@ -109,11 +109,11 @@ void PostTask1(bool* ran_test) {
}
void PostDelayedTask1(bool* ran_test) {
// Currently on the UI thread.
CefRefPtr<CefTaskRunner> runner = CefTaskRunner::GetForThread(TID_IO);
// Currently on the FILE thread.
CefRefPtr<CefTaskRunner> runner = CefTaskRunner::GetForThread(TID_DB);
EXPECT_TRUE(runner.get());
EXPECT_FALSE(runner->BelongsToCurrentThread());
EXPECT_TRUE(runner->BelongsToThread(TID_IO));
EXPECT_TRUE(runner->BelongsToThread(TID_DB));
bool got_it = false;
runner->PostDelayedTask(
@ -126,35 +126,35 @@ void PostDelayedTask1(bool* ran_test) {
}
void PostTaskEvent2(bool* got_it) {
EXPECT_TRUE(CefCurrentlyOn(TID_IO));
EXPECT_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);
}

11
tests/unittests/test_handler.cc
View File

@ -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();
}

20
tests/unittests/test_handler.h
View File

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

26
tests/unittests/thread_helper.cc
View File

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

31
tests/unittests/thread_helper.h
View File

@ -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<CefWaitableEvent> event);
// Post a task to the specified thread and wait for the task to execute as
// indication that all previously pending tasks on that thread have completed.
@ -36,15 +35,14 @@ void WaitForThread(CefRefPtr<CefTaskRunner> task_runner, int64 delay_ms = 0);
// once execution is complete.
void RunOnThread(CefThreadId thread_id,
const base::Callback<void(void)>& test_impl,
base::WaitableEvent* event);
CefRefPtr<CefWaitableEvent> event);
#define NAMED_THREAD_TEST(thread_id, test_case_name, test_name) \
TEST(test_case_name, test_name) { \
base::WaitableEvent event( \
base::WaitableEvent::ResetPolicy::AUTOMATIC, \
base::WaitableEvent::InitialState::NOT_SIGNALED); \
RunOnThread(thread_id, base::Bind(test_name##Impl), &event); \
event.Wait(); \
CefRefPtr<CefWaitableEvent> 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<void(base::WaitableEvent*)>& test_impl,
base::WaitableEvent* event);
const base::Callback<void(CefRefPtr<CefWaitableEvent>)>& test_impl,
CefRefPtr<CefWaitableEvent>);
#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<CefWaitableEvent> 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<CefWaitableEvent> event)".
#define UI_THREAD_TEST_ASYNC(test_case_name, test_name) \
NAMED_THREAD_TEST_ASYNC(TID_UI, test_case_name, test_name)

14
tests/unittests/tracing_unittest.cc
View File

@ -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<CefWaitableEvent> completion_event_;
const char* trace_type_;
TracingTestType type_;

44
tests/unittests/urlrequest_unittest.cc
View File

@ -5,12 +5,11 @@
#include <map>
#include <sstream>
#include "base/synchronization/waitable_event.h"
#include "include/base/cef_bind.h"
#include "include/cef_scheme.h"
#include "include/cef_task.h"
#include "include/cef_urlrequest.h"
#include "include/cef_waitable_event.h"
#include "include/wrapper/cef_closure_task.h"
#include "include/wrapper/cef_scoped_temp_dir.h"
#include "testing/gtest/include/gtest/gtest.h"
@ -149,7 +148,7 @@ void SetTestCookie(CefRefPtr<CefRequestContext> request_context) {
class Callback : public CefSetCookieCallback {
public:
explicit Callback(base::WaitableEvent* event)
explicit Callback(CefRefPtr<CefWaitableEvent> event)
: event_(event) {
EXPECT_TRUE(event_);
}
@ -161,14 +160,13 @@ void SetTestCookie(CefRefPtr<CefRequestContext> request_context) {
}
private:
base::WaitableEvent* event_;
CefRefPtr<CefWaitableEvent> event_;
IMPLEMENT_REFCOUNTING(Callback);
};
base::WaitableEvent event(
base::WaitableEvent::ResetPolicy::MANUAL,
base::WaitableEvent::InitialState::NOT_SIGNALED);
CefRefPtr<CefWaitableEvent> event =
CefWaitableEvent::CreateWaitableEvent(false, false);
CefCookie cookie;
CefString(&cookie.name) = kRequestSendCookieName;
@ -177,11 +175,11 @@ void SetTestCookie(CefRefPtr<CefRequestContext> request_context) {
CefString(&cookie.path) = "/";
cookie.has_expires = false;
EXPECT_TRUE(request_context->GetDefaultCookieManager(NULL)->SetCookie(
kRequestOrigin, cookie, new Callback(&event)));
kRequestOrigin, cookie, new Callback(event)));
// Wait for the Callback.
event.TimedWait(base::TimeDelta::FromSeconds(2));
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<CefRequestContext> request_context,
class Visitor : public CefCookieVisitor {
public:
Visitor(base::WaitableEvent* event, bool* cookie_exists)
Visitor(CefRefPtr<CefWaitableEvent> event, bool* cookie_exists)
: event_(event),
cookie_exists_(cookie_exists) {
EXPECT_TRUE(event_);
@ -213,24 +211,23 @@ void GetTestCookie(CefRefPtr<CefRequestContext> request_context,
}
private:
base::WaitableEvent* event_;
CefRefPtr<CefWaitableEvent> event_;
bool* cookie_exists_;
IMPLEMENT_REFCOUNTING(Visitor);
};
base::WaitableEvent event(
base::WaitableEvent::ResetPolicy::MANUAL,
base::WaitableEvent::InitialState::NOT_SIGNALED);
CefRefPtr<CefWaitableEvent> event =
CefWaitableEvent::CreateWaitableEvent(false, false);
CefRefPtr<CefCookieManager> cookie_manager =
request_context->GetDefaultCookieManager(NULL);
cookie_manager->VisitUrlCookies(
kRequestOrigin, true, new Visitor(&event, cookie_exists));
kRequestOrigin, true, new Visitor(event, cookie_exists));
// Wait for the Visitor.
event.TimedWait(base::TimeDelta::FromSeconds(2));
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<CefURLRequest> client) override {
@ -1549,10 +1545,10 @@ class InvalidURLTestClient : public CefURLRequestClient {
void CompleteOnUIThread() {
EXPECT_UI_THREAD();
// Signal that the test is complete.
event_.Signal();
event_->Signal();
}
base::WaitableEvent event_;
CefRefPtr<CefWaitableEvent> event_;
IMPLEMENT_REFCOUNTING(InvalidURLTestClient);
};

100
tests/unittests/views/button_unittest.cc
View File

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

6
tests/unittests/views/scroll_view_unittest.cc
View File

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

4
tests/unittests/views/test_window_delegate.cc
View File

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

8
tests/unittests/views/test_window_delegate.h
View File

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

2
tests/unittests/views/textfield_unittest.cc
View File

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

28
tests/unittests/views/window_unittest.cc
View File

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

78
tests/unittests/waitable_event_unittest.cc Normal file
View File

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