bcarrella/cef
1
0
Fork 0
mirror of https://bitbucket.org/chromiumembedded/cef synced 2025-01-26 17:25:29 +01:00
Code Issues Packages Projects Releases Wiki Activity

Fix mapping of routing IDs to browser objects (issue #1012).

Browse Source 
git-svn-id: https://chromiumembedded.googlecode.com/svn/trunk@1305 5089003a-bbd8-11dd-ad1f-f1f9622dbc98
This commit is contained in:
Marshall Greenblatt 2013-07-15 20:25:59 +00:00
parent 8118ed28b3
commit 27fac646d9
10 changed files with 623 additions and 37 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
cef.gyp
View File

@ -256,6 +256,7 @@
'tests/unittests/navigation_unittest.cc',
'tests/unittests/os_rendering_unittest.cc',
'tests/unittests/process_message_unittest.cc',
'tests/unittests/request_handler_unittest.cc',
'tests/unittests/request_unittest.cc',
'tests/cefclient/resource_util.h',
'tests/unittests/run_all_unittests.cc',
@ -1277,6 +1278,7 @@
'tests/unittests/dom_unittest.cc',
'tests/unittests/navigation_unittest.cc',
'tests/unittests/process_message_unittest.cc',
'tests/unittests/request_handler_unittest.cc',
'tests/unittests/scheme_handler_unittest.cc',
'tests/unittests/urlrequest_unittest.cc',
'tests/unittests/test_handler.cc',

24
libcef/browser/browser_host_impl.cc
View File

@ -388,11 +388,12 @@ CefRefPtr<CefBrowserHostImpl> CefBrowserHostImpl::GetBrowserForRequest(
DCHECK(request);
CEF_REQUIRE_IOT();
int render_process_id = -1;
int render_view_id = -1;
int render_view_id = MSG_ROUTING_NONE;
if (!content::ResourceRequestInfo::GetRenderViewForRequest(request,
&render_process_id,
&render_view_id)) {
if (!content::ResourceRequestInfo::GetRenderViewForRequest(
request, &render_process_id, &render_view_id) ||
render_process_id == -1 ||
render_view_id == MSG_ROUTING_NONE) {
return NULL;
}
@ -402,6 +403,9 @@ CefRefPtr<CefBrowserHostImpl> CefBrowserHostImpl::GetBrowserForRequest(
// static
CefRefPtr<CefBrowserHostImpl> CefBrowserHostImpl::GetBrowserByRoutingID(
int render_process_id, int render_view_id) {
if (render_process_id == -1 || render_view_id == MSG_ROUTING_NONE)
return NULL;
if (CEF_CURRENTLY_ON_UIT()) {
// Use the non-thread-safe but potentially faster approach.
content::RenderViewHost* render_view_host =
@ -445,7 +449,7 @@ CefRefPtr<CefBrowserHostImpl> CefBrowserHostImpl::GetBrowserByChildID(
return NULL;
} else {
// Use the thread-safe approach.
return _Context->GetBrowserByRoutingID(render_process_id, 0);
return _Context->GetBrowserByRoutingID(render_process_id, -1);
}
}
@ -1793,11 +1797,8 @@ void CefBrowserHostImpl::RequestMediaAccessPermission(
void CefBrowserHostImpl::RenderViewCreated(
content::RenderViewHost* render_view_host) {
// When navigating cross-origin the new (pending) RenderViewHost will be
// created before the old (current) RenderViewHost is destroyed. It may be
// necessary in the future to track both current and pending render IDs.
browser_info_->set_render_ids(render_view_host->GetProcess()->GetID(),
render_view_host->GetRoutingID());
browser_info_->add_render_id(render_view_host->GetProcess()->GetID(),
render_view_host->GetRoutingID());
// Update the DevTools URLs, if any.
CefDevToolsDelegate* devtools_delegate = _Context->devtools_delegate();
@ -1820,6 +1821,9 @@ void CefBrowserHostImpl::RenderViewCreated(
void CefBrowserHostImpl::RenderViewDeleted(
content::RenderViewHost* render_view_host) {
browser_info_->remove_render_id(render_view_host->GetProcess()->GetID(),
render_view_host->GetRoutingID());
if (registrar_->IsRegistered(
this, content::NOTIFICATION_FOCUS_CHANGED_IN_PAGE,
content::Source<content::RenderViewHost>(render_view_host))) {

4
libcef/browser/browser_host_impl.h
View File

@ -100,7 +100,9 @@ class CefBrowserHostImpl : public CefBrowserHost,
// Returns the browser associated with the specified routing IDs.
static CefRefPtr<CefBrowserHostImpl> GetBrowserByRoutingID(
int render_process_id, int render_view_id);
// Returns the browser associated with the specified child process ID.
// Returns the first browser associated with the specified child process ID.
// There may be multiple browsers using the same render process so this method
// should be used with caution.
static CefRefPtr<CefBrowserHostImpl> GetBrowserByChildID(
int render_process_id);

46
libcef/browser/browser_info.cc
View File

@ -8,9 +8,7 @@
CefBrowserInfo::CefBrowserInfo(int browser_id, bool is_popup)
: browser_id_(browser_id),
is_popup_(is_popup),
is_window_rendering_disabled_(false),
render_process_id_(MSG_ROUTING_NONE),
render_view_id_(MSG_ROUTING_NONE) {
is_window_rendering_disabled_(false) {
DCHECK_GT(browser_id, 0);
}
@ -21,19 +19,51 @@ void CefBrowserInfo::set_window_rendering_disabled(bool disabled) {
is_window_rendering_disabled_ = disabled;
}
void CefBrowserInfo::set_render_ids(
void CefBrowserInfo::add_render_id(
int render_process_id, int render_view_id) {
DCHECK_GT(render_process_id, 0);
DCHECK_GT(render_view_id, 0);
base::AutoLock lock_scope(lock_);
render_process_id_ = render_process_id;
render_view_id_ = render_view_id;
if (!render_id_set_.empty()) {
RenderIdSet::const_iterator it =
render_id_set_.find(std::make_pair(render_process_id, render_view_id));
if (it != render_id_set_.end())
return;
}
render_id_set_.insert(std::make_pair(render_process_id, render_view_id));
}
void CefBrowserInfo::remove_render_id(
int render_process_id, int render_view_id) {
DCHECK_GT(render_process_id, 0);
DCHECK_GT(render_view_id, 0);
base::AutoLock lock_scope(lock_);
DCHECK(!render_id_set_.empty());
if (render_id_set_.empty())
return;
RenderIdSet::iterator it =
render_id_set_.find(std::make_pair(render_process_id, render_view_id));
DCHECK(it != render_id_set_.end());
if (it != render_id_set_.end())
render_id_set_.erase(it);
}
bool CefBrowserInfo::is_render_id_match(
int render_process_id, int render_view_id) {
base::AutoLock lock_scope(lock_);
if (render_process_id != render_process_id_)
if (render_id_set_.empty())
return false;
return (render_view_id == 0 || render_view_id == render_view_id_);
RenderIdSet::const_iterator it =
render_id_set_.find(std::make_pair(render_process_id, render_view_id));
return (it != render_id_set_.end());
}
CefRefPtr<CefBrowserHostImpl> CefBrowserInfo::browser() {

21
libcef/browser/browser_info.h
View File

@ -6,6 +6,8 @@
#define CEF_LIBCEF_BROWSER_BROWSER_INFO_H_
#pragma once
#include <set>
#include "libcef/browser/browser_host_impl.h"
#include "base/memory/ref_counted.h"
@ -28,10 +30,11 @@ class CefBrowserInfo : public base::RefCountedThreadSafe<CefBrowserInfo> {
void set_window_rendering_disabled(bool disabled);
void set_render_ids(int render_process_id, int render_view_id);
void add_render_id(int render_process_id, int render_view_id);
void remove_render_id(int render_process_id, int render_view_id);
// Returns true if this browser matches the specified ID values. If
// |render_view_id| is 0 any browser with the specified |render_process_id|
// |render_view_id| is -1 any browser with the specified |render_process_id|
// will match.
bool is_render_id_match(int render_process_id, int render_view_id);
@ -46,8 +49,18 @@ class CefBrowserInfo : public base::RefCountedThreadSafe<CefBrowserInfo> {
base::Lock lock_;
// The below members must be protected by |lock_|.
int render_process_id_;
int render_view_id_;
// Set of mapped (process_id, view_id) pairs. Keeping this set is necessary
// for the following reasons:
// 1. When navigating cross-origin the new (pending) RenderViewHost will be
// created before the old (current) RenderViewHost is destroyed.
// 2. When canceling and asynchronously continuing navigation of the same URL
// a new RenderViewHost may be created for the first (canceled) navigation
// and then destroyed as a result of the second (allowed) navigation.
// 3. Out-of-process iframes have their own render IDs which must also be
// associated with the host browser.
typedef std::set<std::pair<int, int> > RenderIdSet;
RenderIdSet render_id_set_;
// May be NULL if the browser has not yet been created or if the browser has
// been destroyed.

2
libcef/browser/content_browser_client.cc
View File

@ -290,7 +290,7 @@ scoped_refptr<CefBrowserInfo>
// Must be a popup if it hasn't already been created.
scoped_refptr<CefBrowserInfo> browser_info =
new CefBrowserInfo(++next_browser_id_, true);
browser_info->set_render_ids(render_process_id, render_view_id);
browser_info->add_render_id(render_process_id, render_view_id);
browser_info_list_.push_back(browser_info);
return browser_info;
}

4
tests/unittests/client_app_delegates.cc
View File

@ -37,6 +37,10 @@ void ClientApp::CreateRenderDelegates(RenderDelegateSet& delegates) {
// Bring in the Navigation tests.
extern void CreateNavigationRendererTests(RenderDelegateSet& delegates);
CreateNavigationRendererTests(delegates);
// Bring in the RequestHandler tests.
extern void CreateRequestHandlerRendererTests(RenderDelegateSet& delegates);
CreateRequestHandlerRendererTests(delegates);
}
// static

396
tests/unittests/request_handler_unittest.cc Normal file
View File

@ -0,0 +1,396 @@
// Copyright (c) 2013 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 "tests/unittests/test_handler.h"
#include "base/strings/stringprintf.h"
#include "base/strings/string_number_conversions.h"
#include "include/cef_cookie.h"
#include "include/cef_runnable.h"
#include "testing/gtest/include/gtest/gtest.h"
#include "tests/cefclient/client_app.h"
namespace {
enum NetNotifyTestType {
NNTT_NONE = 0,
NNTT_NORMAL,
NNTT_DELAYED_RENDERER,
NNTT_DELAYED_BROWSER,
};
const char kNetNotifyOrigin1[] = "http://tests-netnotify1/";
const char kNetNotifyOrigin2[] = "http://tests-netnotify2/";
const char kNetNotifyMsg[] = "RequestHandlerTest.NetNotify";
// Browser side.
class NetNotifyTestHandler : public TestHandler {
public:
NetNotifyTestHandler(CompletionState* completion_state,
NetNotifyTestType test_type,
bool same_origin)
: TestHandler(completion_state),
test_type_(test_type),
same_origin_(same_origin) {}
virtual void SetupTest() OVERRIDE {
url1_ = base::StringPrintf("%snav1.html?t=%d",
kNetNotifyOrigin1, test_type_);
url2_ = base::StringPrintf("%snav2.html?t=%d",
same_origin_ ? kNetNotifyOrigin1 : kNetNotifyOrigin2, test_type_);
cookie_manager_ = CefCookieManager::CreateManager(CefString(), true);
AddResource(url1_,
"<html>"
"<head><script>document.cookie='name1=value1';</script></head>"
"<body>Nav1</body>"
"</html>", "text/html");
AddResource(url2_,
"<html>"
"<head><script>document.cookie='name2=value2';</script></head>"
"<body>Nav2</body>"
"</html>", "text/html");
// Create browser that loads the 1st URL.
CreateBrowser(url1_);
}
virtual void RunTest() OVERRIDE {
// Navigate to the 2nd URL.
GetBrowser()->GetMainFrame()->LoadURL(url2_);
}
virtual bool OnBeforeResourceLoad(CefRefPtr<CefBrowser> browser,
CefRefPtr<CefFrame> frame,
CefRefPtr<CefRequest> request) OVERRIDE {
EXPECT_TRUE(CefCurrentlyOn(TID_IO));
const std::string& url = request->GetURL();
if (url.find(url1_) == 0)
got_before_resource_load1_.yes();
else if (url.find(url2_) == 0)
got_before_resource_load2_.yes();
else
EXPECT_TRUE(false); // Not reached
return false;
}
virtual CefRefPtr<CefResourceHandler> GetResourceHandler(
CefRefPtr<CefBrowser> browser,
CefRefPtr<CefFrame> frame,
CefRefPtr<CefRequest> request) OVERRIDE {
EXPECT_TRUE(CefCurrentlyOn(TID_IO));
const std::string& url = request->GetURL();
if (url.find(url1_) == 0)
got_get_resource_handler1_.yes();
else if (url.find(url2_) == 0)
got_get_resource_handler2_.yes();
else
EXPECT_TRUE(false); // Not reached
return TestHandler::GetResourceHandler(browser, frame, request);
}
virtual CefRefPtr<CefCookieManager> GetCookieManager(
CefRefPtr<CefBrowser> browser,
const CefString& main_url) OVERRIDE {
EXPECT_TRUE(CefCurrentlyOn(TID_IO));
const std::string& url = main_url;
if (url.find(url1_) == 0)
got_get_cookie_manager1_.yes();
else if (url.find(url2_) == 0)
got_get_cookie_manager2_.yes();
else
EXPECT_TRUE(false); // Not reached
return cookie_manager_;
}
virtual void OnLoadEnd(CefRefPtr<CefBrowser> browser,
CefRefPtr<CefFrame> frame,
int httpStatusCode) OVERRIDE {
const std::string& url = frame->GetURL();
if (url.find(url1_) == 0) {
got_load_end1_.yes();
SetupComplete();
} else if (url.find(url2_) == 0) {
got_load_end2_.yes();
FinishTest();
} else {
EXPECT_TRUE(false); // Not reached
}
}
virtual bool OnProcessMessageReceived(
CefRefPtr<CefBrowser> browser,
CefProcessId source_process,
CefRefPtr<CefProcessMessage> message) OVERRIDE {
if (message->GetName().ToString() == kNetNotifyMsg) {
CefRefPtr<CefListValue> args = message->GetArgumentList();
EXPECT_TRUE(args.get());
NetNotifyTestType test_type =
static_cast<NetNotifyTestType>(args->GetInt(0));
EXPECT_EQ(test_type, test_type_);
std::string url = args->GetString(1);
if (url.find(url1_) == 0)
got_process_message1_.yes();
else if (url.find(url2_) == 0)
got_process_message2_.yes();
else
EXPECT_TRUE(false); // Not reached
// Navigating cross-origin from the browser process will cause a new
// render process to be created. We therefore need some information in
// the request itself to tell us that the navigation has already been
// delayed.
url += "&delayed=true";
if (test_type == NNTT_DELAYED_RENDERER) {
// Load the URL from the render process.
CefRefPtr<CefProcessMessage> message =
CefProcessMessage::Create(kNetNotifyMsg);
CefRefPtr<CefListValue> args = message->GetArgumentList();
args->SetInt(0, test_type);
args->SetString(1, url);
EXPECT_TRUE(browser->SendProcessMessage(PID_RENDERER, message));
} else {
// Load the URL from the browser process.
browser->GetMainFrame()->LoadURL(url);
}
return true;
}
// Message not handled.
return false;
}
protected:
void FinishTest() {
//Verify that cookies were set correctly.
class TestVisitor : public CefCookieVisitor {
public:
explicit TestVisitor(NetNotifyTestHandler* handler)
: handler_(handler) {
}
virtual ~TestVisitor() {
// Destroy the test.
CefPostTask(TID_UI,
NewCefRunnableMethod(handler_, &NetNotifyTestHandler::DestroyTest));
}
virtual bool Visit(const CefCookie& cookie, int count, int total,
bool& deleteCookie) {
const std::string& name = CefString(&cookie.name);
const std::string& value = CefString(&cookie.value);
if (name == "name1" && value == "value1")
handler_->got_cookie1_.yes();
else if (name == "name2" && value == "value2")
handler_->got_cookie2_.yes();
return true;
}
private:
NetNotifyTestHandler* handler_;
IMPLEMENT_REFCOUNTING(TestVisitor);
};
cookie_manager_->VisitAllCookies(new TestVisitor(this));
}
virtual void DestroyTest() OVERRIDE {
int browser_id = GetBrowser()->GetIdentifier();
// Verify test expectations.
EXPECT_TRUE(got_load_end1_) << " browser " << browser_id;
EXPECT_TRUE(got_before_resource_load1_) << " browser " << browser_id;
EXPECT_TRUE(got_get_resource_handler1_) << " browser " << browser_id;
EXPECT_TRUE(got_get_cookie_manager1_) << " browser " << browser_id;
EXPECT_TRUE(got_cookie1_) << " browser " << browser_id;
EXPECT_TRUE(got_load_end2_) << " browser " << browser_id;
EXPECT_TRUE(got_before_resource_load2_) << " browser " << browser_id;
EXPECT_TRUE(got_get_resource_handler2_) << " browser " << browser_id;
EXPECT_TRUE(got_get_cookie_manager2_) << " browser " << browser_id;
EXPECT_TRUE(got_cookie2_) << " browser " << browser_id;
if (test_type_ == NNTT_DELAYED_RENDERER ||
test_type_ == NNTT_DELAYED_BROWSER) {
EXPECT_TRUE(got_process_message1_) << " browser " << browser_id;
EXPECT_TRUE(got_process_message2_) << " browser " << browser_id;
} else {
EXPECT_FALSE(got_process_message1_) << " browser " << browser_id;
EXPECT_FALSE(got_process_message2_) << " browser " << browser_id;
}
cookie_manager_ = NULL;
TestHandler::DestroyTest();
}
NetNotifyTestType test_type_;
bool same_origin_;
std::string url1_;
std::string url2_;
CefRefPtr<CefCookieManager> cookie_manager_;
TrackCallback got_load_end1_;
TrackCallback got_before_resource_load1_;
TrackCallback got_get_resource_handler1_;
TrackCallback got_get_cookie_manager1_;
TrackCallback got_cookie1_;
TrackCallback got_process_message1_;
TrackCallback got_load_end2_;
TrackCallback got_before_resource_load2_;
TrackCallback got_get_resource_handler2_;
TrackCallback got_get_cookie_manager2_;
TrackCallback got_cookie2_;
TrackCallback got_process_message2_;
};
// Renderer side.
class NetNotifyRendererTest : public ClientApp::RenderDelegate {
public:
NetNotifyRendererTest() {}
virtual bool OnBeforeNavigation(CefRefPtr<ClientApp> app,
CefRefPtr<CefBrowser> browser,
CefRefPtr<CefFrame> frame,
CefRefPtr<CefRequest> request,
cef_navigation_type_t navigation_type,
bool is_redirect) OVERRIDE {
const std::string& url = request->GetURL();
// Don't execute this method for unrelated tests.
if (url.find(kNetNotifyOrigin1) == std::string::npos &&
url.find(kNetNotifyOrigin2) == std::string::npos) {
return false;
}
NetNotifyTestType test_type = NNTT_NONE;
// Extract the test type.
int pos = url.find("t=");
int intval = 0;
if (pos > 0 && base::StringToInt(url.substr(pos + 2, 1), &intval))
test_type = static_cast<NetNotifyTestType>(intval);
EXPECT_GT(test_type, NNTT_NONE);
// Check if the load has already been delayed.
bool delay_loaded = (url.find("delayed=true") != std::string::npos);
if (!delay_loaded && (test_type == NNTT_DELAYED_RENDERER ||
test_type == NNTT_DELAYED_BROWSER)) {
// Delay load the URL.
CefRefPtr<CefProcessMessage> message =
CefProcessMessage::Create(kNetNotifyMsg);
CefRefPtr<CefListValue> args = message->GetArgumentList();
args->SetInt(0, test_type);
args->SetString(1, url);
EXPECT_TRUE(browser->SendProcessMessage(PID_BROWSER, message));
return true;
}
return false;
}
virtual bool OnProcessMessageReceived(
CefRefPtr<ClientApp> app,
CefRefPtr<CefBrowser> browser,
CefProcessId source_process,
CefRefPtr<CefProcessMessage> message) OVERRIDE {
if (message->GetName().ToString() == kNetNotifyMsg) {
CefRefPtr<CefListValue> args = message->GetArgumentList();
EXPECT_TRUE(args.get());
NetNotifyTestType test_type =
static_cast<NetNotifyTestType>(args->GetInt(0));
EXPECT_EQ(test_type, NNTT_DELAYED_RENDERER);
const std::string& url = args->GetString(1);
// Load the URL from the render process.
browser->GetMainFrame()->LoadURL(url);
return true;
}
// Message not handled.
return false;
}
IMPLEMENT_REFCOUNTING(NetNotifyRendererTest);
};
void RunNetNotifyTest(NetNotifyTestType test_type, bool same_origin) {
TestHandler::CompletionState completion_state(3);
CefRefPtr<NetNotifyTestHandler> handler1 =
new NetNotifyTestHandler(&completion_state, test_type, same_origin);
CefRefPtr<NetNotifyTestHandler> handler2 =
new NetNotifyTestHandler(&completion_state, test_type, same_origin);
CefRefPtr<NetNotifyTestHandler> handler3 =
new NetNotifyTestHandler(&completion_state, test_type, same_origin);
TestHandler::Collection collection(&completion_state);
collection.AddTestHandler(handler1.get());
collection.AddTestHandler(handler2.get());
collection.AddTestHandler(handler3.get());
collection.ExecuteTests();
}
} // namespace
// Verify network notifications for multiple browsers existing simultaniously.
// URL loading is from the same origin and is not delayed.
TEST(RequestHandlerTest, NotificationsSameOriginDirect) {
RunNetNotifyTest(NNTT_NORMAL, true);
}
// Verify network notifications for multiple browsers existing simultaniously.
// URL loading is from the same origin and is continued asynchronously from the
// render process.
TEST(RequestHandlerTest, NotificationsSameOriginDelayedRenderer) {
RunNetNotifyTest(NNTT_DELAYED_RENDERER, true);
}
// Verify network notifications for multiple browsers existing simultaniously.
// URL loading is from the same origin and is continued asynchronously from the
// browser process.
TEST(RequestHandlerTest, NotificationsSameOriginDelayedBrowser) {
RunNetNotifyTest(NNTT_DELAYED_BROWSER, true);
}
// Verify network notifications for multiple browsers existing simultaniously.
// URL loading is from a different origin and is not delayed.
TEST(RequestHandlerTest, NotificationsCrossOriginDirect) {
RunNetNotifyTest(NNTT_NORMAL, false);
}
// Verify network notifications for multiple browsers existing simultaniously.
// URL loading is from a different origin and is continued asynchronously from
// the render process.
TEST(RequestHandlerTest, NotificationsCrossOriginDelayedRenderer) {
RunNetNotifyTest(NNTT_DELAYED_RENDERER, false);
}
// Verify network notifications for multiple browsers existing simultaniously.
// URL loading is from a different origin and is continued asynchronously from
// the browser process.
TEST(RequestHandlerTest, NotificationsCrossOriginDelayedBrowser) {
RunNetNotifyTest(NNTT_DELAYED_BROWSER, false);
}
// Entry point for creating request handler renderer test objects.
// Called from client_app_delegates.cc.
void CreateRequestHandlerRendererTests(
ClientApp::RenderDelegateSet& delegates) {
delegates.insert(new NetNotifyRendererTest);
}

83
tests/unittests/test_handler.cc
View File

@ -3,6 +3,7 @@
// can be found in the LICENSE file.
#include "tests/unittests/test_handler.h"
#include "base/logging.h"
#include "include/cef_command_line.h"
#include "include/cef_runnable.h"
#include "include/cef_stream.h"
@ -17,16 +18,80 @@ void NotifyEvent(base::WaitableEvent* event) {
} // namespace
// TestHandler::CompletionState
TestHandler::CompletionState::CompletionState(int total)
: total_(total),
count_(0),
event_(true, false) {
}
void TestHandler::CompletionState::TestComplete() {
if (++count_ == total_) {
// Signal that the test is now complete.
event_.Signal();
count_ = 0;
}
}
void TestHandler::CompletionState::WaitForTests() {
// Wait for the test to complete
event_.Wait();
// Reset the event so the same test can be executed again.
event_.Reset();
}
// TestHandler::Collection
TestHandler::Collection::Collection(CompletionState* completion_state)
: completion_state_(completion_state) {
DCHECK(completion_state_);
}
void TestHandler::Collection::AddTestHandler(TestHandler* test_handler) {
DCHECK_EQ(test_handler->completion_state_, completion_state_);
handler_list_.push_back(test_handler);
}
void TestHandler::Collection::ExecuteTests() {
DCHECK_GT(handler_list_.size(), 0UL);
TestHandlerList::const_iterator it;
it = handler_list_.begin();
for (; it != handler_list_.end(); ++it)
(*it)->SetupTest();
completion_state_->WaitForTests();
it = handler_list_.begin();
for (; it != handler_list_.end(); ++it)
(*it)->RunTest();
completion_state_->WaitForTests();
}
// TestHandler
int TestHandler::browser_count_ = 0;
TestHandler::TestHandler()
: browser_id_(0),
completion_event_(true, false) {
TestHandler::TestHandler(CompletionState* completion_state)
: browser_id_(0) {
if (completion_state) {
completion_state_ = completion_state;
completion_state_owned_ = false;
} else {
completion_state_ = new CompletionState(1);
completion_state_owned_ = true;
}
}
TestHandler::~TestHandler() {
if (completion_state_owned_)
delete completion_state_;
}
void TestHandler::OnAfterCreated(CefRefPtr<CefBrowser> browser) {
@ -49,7 +114,7 @@ void TestHandler::OnBeforeClose(CefRefPtr<CefBrowser> browser) {
browser_id_ = 0;
// Signal that the test is now complete.
completion_event_.Signal();
completion_state_->TestComplete();
}
}
@ -86,14 +151,18 @@ CefRefPtr<CefResourceHandler> TestHandler::GetResourceHandler(
}
void TestHandler::ExecuteTest() {
DCHECK_EQ(completion_state_->total(), 1);
// Run the test
RunTest();
// Wait for the test to complete
completion_event_.Wait();
completion_state_->WaitForTests();
}
// Reset the event so the same test can be executed again.
completion_event_.Reset();
void TestHandler::SetupComplete() {
// Signal that the test setup is complete.
completion_state_->TestComplete();
}
void TestHandler::DestroyTest() {

78
tests/unittests/test_handler.h
View File

@ -6,6 +6,7 @@
#define CEF_TESTS_UNITTESTS_TEST_HANDLER_H_
#pragma once
#include <list>
#include <map>
#include <string>
#include <utility>
@ -28,6 +29,7 @@ class TrackCallback {
bool gotit_;
};
// Base implementation of CefClient for unit tests. Add new interfaces as needed
// by test cases.
class TestHandler : public CefClient,
@ -40,10 +42,68 @@ class TestHandler : public CefClient,
public CefLoadHandler,
public CefRequestHandler {
public:
TestHandler();
// Tracks the completion state of related test runs.
class CompletionState {
public:
// |total| is the number of times that TestComplete() must be called before
// WaitForTests() will return.
explicit CompletionState(int total);
// Call this method to indicate that a test has completed.
void TestComplete();
// This method blocks until TestComplete() has been called the required
// number of times.
void WaitForTests();
int total() const { return total_; }
int count() const { return count_; }
private:
int total_;
int count_;
// Handle used to notify when the test is complete
base::WaitableEvent event_;
};
// Represents a collection of related tests that need to be run
// simultaniously.
class Collection {
public:
// The |completion_state| object must outlive this class.
explicit Collection(CompletionState* completion_state);
// The |test_handler| object must outlive this class and it must share the
// same CompletionState object passed to the constructor.
void AddTestHandler(TestHandler* test_handler);
// Manages the test run.
// 1. Calls TestHandler::SetupTest() for all of the test objects.
// 2. Waits for all TestHandler objects to report that initial setup is
// complete by calling TestHandler::SetupComplete().
// 3. Calls TestHandler::RunTest() for all of the test objects.
// 4. Waits for all TestHandler objects to report that the test is
// complete by calling TestHandler::DestroyTest().
void ExecuteTests();
private:
CompletionState* completion_state_;
typedef std::list<TestHandler*> TestHandlerList;
TestHandlerList handler_list_;
};
// The |completion_state| object if specified must outlive this class.
explicit TestHandler(CompletionState* completion_state = NULL);
virtual ~TestHandler();
// Implement this method to run the test
// Implement this method to set up the test. Only used in combination with a
// Collection. Call SetupComplete() once the setup is complete.
virtual void SetupTest() {}
// Implement this method to run the test. Call DestroyTest() once the test is
// complete.
virtual void RunTest() =0;
// CefClient methods. Add new methods as needed by test cases.
@ -92,15 +152,20 @@ class TestHandler : public CefClient,
CefRefPtr<CefBrowser> GetBrowser() { return browser_; }
int GetBrowserId() { return browser_id_; }
// Called by the test function to execute the test. This method blocks until
// Called by the test function to execute the test. This method blocks until
// the test is complete. Do not reference the object after this method
// returns.
// returns. Do not use this method if the CompletionState object is shared by
// multiple handlers or when using a Collection object.
void ExecuteTest();
// Returns true if a browser currently exists.
static bool HasBrowser() { return browser_count_ > 0; }
protected:
// Indicate that test setup is complete. Only used in combination with a
// Collection.
virtual void SetupComplete();
// Destroy the browser window. Once the window is destroyed test completion
// will be signaled.
virtual void DestroyTest();
@ -119,8 +184,9 @@ class TestHandler : public CefClient,
// The browser window identifier
int browser_id_;
// Handle used to notify when the test is complete
base::WaitableEvent completion_event_;
// Used to notify when the test is complete
CompletionState* completion_state_;
bool completion_state_owned_;
// Map of resources that can be automatically loaded
typedef std::map<std::string, std::pair<std::string, std::string> >