cef/tests/ceftests/frame_unittest.cc

2351 lines
71 KiB
C++

// Copyright (c) 2014 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 "include/base/cef_bind.h"
#include "include/base/cef_scoped_ptr.h"
#include "include/wrapper/cef_closure_task.h"
#include "include/wrapper/cef_stream_resource_handler.h"
#include "tests/ceftests/test_handler.h"
#include "tests/gtest/include/gtest/gtest.h"
#include "tests/shared/browser/client_app_browser.h"
#include "tests/shared/renderer/client_app_renderer.h"
using client::ClientAppBrowser;
using client::ClientAppRenderer;
namespace {
// The frame navigation test harness work as follows:
//
// In the browser process:
// 1. TEST() function creates a new FrameNavTestHandler instance with a unique
// FrameNavFactoryId.
// 2. FrameNavTestHandler calls FrameNavExpectationsFactoryBrowser::FromID to
// create a new factory instance.
// 3. FrameNavTestHandler calls FrameNavExpectationsFactoryBrowser::Create to
// create a new FrameNavExpectationsBrowser instance for the current
// navigation.
// 4. FrameNavTestHandler retrieves the URL to load via
// FrameNavExpectationsBrowser::GetMainURL and calls either CreateBrowser
// (for the first navigation) or LoadURL (for the following navigations).
// 5. If the renderer process does not already exist CEF creates it with
// command-line arguments that specify the FrameNavFactoryId via
// FrameNavBrowserTest::OnBeforeChildProcessLaunch.
//
// In the renderer process:
// 6. If the renderer process is newly created FrameNavRendererTest calls
// FrameNavExpectationsFactoryRenderer::FromID to create a new factory
// instance.
// 7. FrameNavRendererTest calls FrameNavExpectationsFactoryRenderer::Create to
// create a new FrameNavExpectationsRenderer instance for the current
// navigation.
//
// In both processes:
// 8. Callback notifications are sent to the FrameNavExpectations* instances.
//
// In the renderer process:
// 9. When the FrameNavExpectationsRenderer instance determines that the
// renderer side of the test is complete it calls SignalComplete which
// finalizes and deletes the FrameNavExpectationsRenderer instance and
// sends an IPC message to the browser process.
//
// In the browser process:
// 11.FrameNavExpectationsBrowser::OnRendererComplete is called in response to
// renderer-side test completion message.
// 12.When the FrameNavExpectationsBrowser instance determines that the browser
// side of the test is complete it calls SignalComplete which finalizes and
// deletes the FrameNavExpectationsBrowser instance.
// 13.If FrameNavExpectationsFactoryBrowser::HasMoreNavigations returns false
// then DestroyTest is called and the test ends. Otherwise, the navigation
// count is incremented and the process repeats starting with step #3.
//
//
// To add a new test case:
// 1. Add a new value to the FrameNavFactoryId enumeration.
// 2. Provide implementations of FrameNavExpectations*.
// 3. Add a case for the new factory ID to FrameNavExpectationsFactory*::FromID.
// 4. Implement a TEST() function that creates a FrameNavTestHandler instance
// and passes the new factory ID.
//
//
// Run with the `--single-process` command-line flag to see expectation failures
// from the renderer process.
//
// All known factory IDs.
enum FrameNavFactoryId {
FNF_ID_INVALID = 0,
FNF_ID_SINGLE_NAV_HARNESS,
FNF_ID_SINGLE_NAV,
FNF_ID_MULTI_NAV_HARNESS,
FNF_ID_MULTI_NAV,
FNF_ID_NESTED_IFRAMES_SAME_ORIGIN,
FNF_ID_NESTED_IFRAMES_DIFF_ORIGIN,
};
// Command-line argument names.
const char kTestArg[] = "test";
const char kTestFactoryIdArg[] = "testfid";
// IPC message name.
const char kFrameNavMsg[] = "FrameTest.Navigation";
// Origins used in tests.
const char kFrameNavOrigin0[] = "http://tests-framenav0.com/";
const char kFrameNavOrigin1[] = "http://tests-framenav1.com/";
const char kFrameNavOrigin2[] = "http://tests-framenav2.com/";
// Maximum number of navigations. Should be kept synchronized with the number
// of kFrameNavOrigin* values. Don't modify this value without checking the
// below use cases.
const int kMaxMultiNavNavigations = 3;
// Global variables identifying the currently running test.
bool g_frame_nav_test = false;
FrameNavFactoryId g_frame_nav_factory_id = FNF_ID_INVALID;
// Abstract base class representing expectations that result from a navigation.
class FrameNavExpectations {
public:
typedef base::Callback<void(CefRefPtr<CefBrowser>)> CompletionCallback;
FrameNavExpectations(int nav, bool renderer)
: nav_(nav),
renderer_(renderer) {
}
virtual ~FrameNavExpectations() {}
// Browser and renderer notifications.
virtual bool OnLoadingStateChange(CefRefPtr<CefBrowser> browser,
bool isLoading) { return true; }
virtual bool OnLoadStart(CefRefPtr<CefBrowser> browser,
CefRefPtr<CefFrame> frame) { return true; }
virtual bool OnLoadEnd(CefRefPtr<CefBrowser> browser,
CefRefPtr<CefFrame> frame) { return true; }
// Final expectations check before this object is deleted.
virtual bool Finalize() =0;
// Signal that all expectations are completed. Should be called as a result of
// notifications.
void SignalComplete(CefRefPtr<CefBrowser> browser) {
if (!completion_callback_.is_null()) {
// Execute the callback asynchronously to avoid any issues with what's
// currently on the stack.
CefPostTask((renderer_ ? TID_RENDERER: TID_UI),
base::Bind(completion_callback_, browser));
completion_callback_.Reset();
}
}
// Returns the current navigation count. In the browser process this value
// increments over the life span of the FrameNavTestHandler instance. In the
// renderer process this value increments over the life span of a single
// renderer instance (i.e. cross-origin navigations will cause this value to
// reset).
int nav() const { return nav_; }
// Returns true if this is a renderer-side expectation object.
bool renderer() const { return renderer_; }
void set_completion_callback(const CompletionCallback& completion_callback) {
completion_callback_ = completion_callback;
}
private:
int nav_;
bool renderer_;
CompletionCallback completion_callback_;
};
// Browser process expectations abstact base class.
class FrameNavExpectationsBrowser : public FrameNavExpectations {
public:
explicit FrameNavExpectationsBrowser(int nav)
: FrameNavExpectations(nav, false) {
}
// Loading information.
virtual std::string GetMainURL() =0;
virtual std::string GetContentForURL(const std::string& url) =0;
// Browser-only notifications.
virtual bool OnAfterCreated(CefRefPtr<CefBrowser> browser) {
EXPECT_TRUE(browser.get());
return true;
}
virtual bool OnBeforeBrowse(CefRefPtr<CefBrowser> browser,
CefRefPtr<CefFrame> frame,
const std::string& url) {
EXPECT_TRUE(browser.get());
EXPECT_TRUE(frame.get());
EXPECT_FALSE(url.empty());
return true;
}
virtual bool GetResourceHandler(CefRefPtr<CefBrowser> browser,
CefRefPtr<CefFrame> frame) {
EXPECT_TRUE(browser.get());
EXPECT_TRUE(frame.get());
return true;
}
// Called when the renderer signals completion.
virtual bool OnRendererComplete(CefRefPtr<CefBrowser> browser,
int renderer_nav,
bool renderer_result) =0;
};
// Renderer process expectations abstract base class.
class FrameNavExpectationsRenderer : public FrameNavExpectations {
public:
explicit FrameNavExpectationsRenderer(int nav)
: FrameNavExpectations(nav, true) {
}
// Renderer-only notifications.
virtual bool OnBeforeNavigation(CefRefPtr<CefBrowser> browser,
CefRefPtr<CefFrame> frame) { return true; }
};
// Abstract base class for the factory that creates expectations objects.
class FrameNavExpectationsFactory {
public:
FrameNavExpectationsFactory() {}
virtual ~FrameNavExpectationsFactory() {}
// Returns the unique ID for this factory type.
virtual FrameNavFactoryId GetID() const =0;
};
// Browser process expectations factory abstact base class.
class FrameNavExpectationsFactoryBrowser : public FrameNavExpectationsFactory {
public:
FrameNavExpectationsFactoryBrowser() {}
// Create a new factory instance of the specified type.
static scoped_ptr<FrameNavExpectationsFactoryBrowser>
FromID(FrameNavFactoryId id);
// Returns true if there will be more navigations in the browser process
// handler.
virtual bool HasMoreNavigations() const =0;
// Verify final expectations results.
virtual bool Finalize() =0;
scoped_ptr<FrameNavExpectationsBrowser> Create(
int nav,
const FrameNavExpectations::CompletionCallback& completion_callback) {
scoped_ptr<FrameNavExpectationsBrowser> expectations;
expectations = Create(nav);
expectations->set_completion_callback(completion_callback);
return expectations.Pass();
}
protected:
// Implement in the test-specific factory instance.
virtual scoped_ptr<FrameNavExpectationsBrowser> Create(int nav) =0;
};
// Renderer process expectations factory abstact base class.
class FrameNavExpectationsFactoryRenderer : public FrameNavExpectationsFactory {
public:
FrameNavExpectationsFactoryRenderer() {}
// Create a new factory instance of the specified type.
static scoped_ptr<FrameNavExpectationsFactoryRenderer>
FromID(FrameNavFactoryId id);
scoped_ptr<FrameNavExpectationsRenderer> Create(
int nav,
const FrameNavExpectations::CompletionCallback& completion_callback) {
scoped_ptr<FrameNavExpectationsRenderer> expectations;
expectations = Create(nav);
expectations->set_completion_callback(completion_callback);
return expectations.Pass();
}
protected:
// Implement in the test-specific factory instance.
virtual scoped_ptr<FrameNavExpectationsRenderer> Create(int nav) =0;
};
// Browser side app delegate.
class FrameNavBrowserTest : public ClientAppBrowser::Delegate {
public:
FrameNavBrowserTest() {}
void OnBeforeChildProcessLaunch(
CefRefPtr<ClientAppBrowser> app,
CefRefPtr<CefCommandLine> command_line) override {
if (!g_frame_nav_test)
return;
std::stringstream ss;
ss << g_frame_nav_factory_id;
// Indicate to the render process that the test should be run.
command_line->AppendSwitchWithValue(kTestArg, kFrameNavMsg);
command_line->AppendSwitchWithValue(kTestFactoryIdArg, ss.str());
}
protected:
IMPLEMENT_REFCOUNTING(FrameNavBrowserTest);
};
// Renderer side handler.
class FrameNavRendererTest : public ClientAppRenderer::Delegate,
public CefLoadHandler {
public:
FrameNavRendererTest()
: run_test_(false),
nav_(0) {}
void OnRenderThreadCreated(
CefRefPtr<ClientAppRenderer> app,
CefRefPtr<CefListValue> extra_info) override {
// The g_* values will be set when running in single-process mode.
if (!g_frame_nav_test) {
// Check that the test should be run.
CefRefPtr<CefCommandLine> command_line =
CefCommandLine::GetGlobalCommandLine();
const std::string& test = command_line->GetSwitchValue(kTestArg);
if (test != kFrameNavMsg)
return;
}
FrameNavFactoryId factory_id = g_frame_nav_factory_id;
if (factory_id == FNF_ID_INVALID) {
// Retrieve the factory ID from the command-line.
CefRefPtr<CefCommandLine> command_line =
CefCommandLine::GetGlobalCommandLine();
if (command_line->HasSwitch(kTestFactoryIdArg)) {
factory_id = static_cast<FrameNavFactoryId>(
atoi(command_line->GetSwitchValue(
kTestFactoryIdArg).ToString().c_str()));
if (factory_id == FNF_ID_INVALID)
return;
}
}
run_test_ = true;
factory_ = FrameNavExpectationsFactoryRenderer::FromID(factory_id);
}
CefRefPtr<CefLoadHandler> GetLoadHandler(
CefRefPtr<ClientAppRenderer> app) override {
if (!run_test_)
return NULL;
return this;
}
void OnLoadingStateChange(CefRefPtr<CefBrowser> browser,
bool isLoading,
bool canGoBack,
bool canGoForward) override {
CreateExpectationsIfNecessary();
EXPECT_TRUE(expectations_->OnLoadingStateChange(browser, isLoading)) <<
"isLoading = " << isLoading << ", nav = " << nav_;
}
void OnLoadStart(CefRefPtr<CefBrowser> browser,
CefRefPtr<CefFrame> frame,
TransitionType transition_type) override {
CreateExpectationsIfNecessary();
EXPECT_TRUE(expectations_->OnLoadStart(browser, frame)) << "nav = " << nav_;
}
void OnLoadEnd(CefRefPtr<CefBrowser> browser,
CefRefPtr<CefFrame> frame,
int httpStatusCode) override {
CreateExpectationsIfNecessary();
EXPECT_TRUE(expectations_->OnLoadEnd(browser, frame)) << "nav = " << nav_;
}
bool OnBeforeNavigation(CefRefPtr<ClientAppRenderer> app,
CefRefPtr<CefBrowser> browser,
CefRefPtr<CefFrame> frame,
CefRefPtr<CefRequest> request,
cef_navigation_type_t navigation_type,
bool is_redirect) override {
if (!run_test_)
return false;
CreateExpectationsIfNecessary();
EXPECT_TRUE(expectations_->OnBeforeNavigation(browser, frame)) <<
"nav = " << nav_;
return false;
}
protected:
// Create a new expectations object if one does not already exist for the
// current navigation.
void CreateExpectationsIfNecessary() {
if (expectations_)
return;
expectations_ = factory_->Create(
nav_,
base::Bind(&FrameNavRendererTest::SendTestResults, this));
}
// Send the test results.
// Will be called via FrameNavExpectations::SignalComplete.
void SendTestResults(CefRefPtr<CefBrowser> browser) {
// End of the current expectations object.
EXPECT_TRUE(expectations_->Finalize()) << "nav = " << nav_;
expectations_.reset(NULL);
// Check if the test has failed.
bool result = !TestFailed();
// Return the result to the browser process.
CefRefPtr<CefProcessMessage> return_msg =
CefProcessMessage::Create(kFrameNavMsg);
CefRefPtr<CefListValue> args = return_msg->GetArgumentList();
EXPECT_TRUE(args.get());
EXPECT_TRUE(args->SetInt(0, nav_));
EXPECT_TRUE(args->SetBool(1, result));
EXPECT_TRUE(browser->SendProcessMessage(PID_BROWSER, return_msg));
nav_++;
}
bool run_test_;
int nav_;
scoped_ptr<FrameNavExpectationsFactoryRenderer> factory_;
scoped_ptr<FrameNavExpectationsRenderer> expectations_;
IMPLEMENT_REFCOUNTING(FrameNavRendererTest);
};
// Browser side handler.
class FrameNavTestHandler : public TestHandler {
public:
explicit FrameNavTestHandler(FrameNavFactoryId factory_id)
: nav_(0),
factory_(FrameNavExpectationsFactoryBrowser::FromID(factory_id)) {
EXPECT_FALSE(g_frame_nav_test);
EXPECT_EQ(FNF_ID_INVALID, g_frame_nav_factory_id);
g_frame_nav_test = true;
g_frame_nav_factory_id = factory_id;
}
~FrameNavTestHandler() override {
EXPECT_TRUE(got_destroyed_);
g_frame_nav_test = false;
g_frame_nav_factory_id = FNF_ID_INVALID;
}
void RunTest() override {
// Create the first expectations object.
expectations_ = factory_->Create(
nav_,
base::Bind(&FrameNavTestHandler::RunNextNav, this));
// Create the browser with the initial URL.
CreateBrowser(expectations_->GetMainURL());
// Time out the test after a reasonable period of time.
SetTestTimeout();
}
// Transition to the next navigation.
// Will be called via FrameNavExpectations::SignalComplete.
void RunNextNav(CefRefPtr<CefBrowser> browser) {
// End of the current expectations object.
EXPECT_TRUE(expectations_->Finalize());
expectations_.reset(NULL);
if (!factory_->HasMoreNavigations()) {
// End of the test.
DestroyTest();
return;
}
nav_++;
// Create the next expectations object.
expectations_ = factory_->Create(
nav_,
base::Bind(&FrameNavTestHandler::RunNextNav, this));
// Load the main URL.
browser->GetMainFrame()->LoadURL(expectations_->GetMainURL());
}
void OnAfterCreated(CefRefPtr<CefBrowser> browser) override {
TestHandler::OnAfterCreated(browser);
EXPECT_TRUE(expectations_->OnAfterCreated(browser)) << "nav = " << nav_;
}
CefRefPtr<CefResourceHandler> GetResourceHandler(
CefRefPtr<CefBrowser> browser,
CefRefPtr<CefFrame> frame,
CefRefPtr<CefRequest> request) override {
EXPECT_TRUE(expectations_->GetResourceHandler(browser, frame)) <<
"nav = " << nav_;
const std::string& url = request->GetURL();
const std::string& content = expectations_->GetContentForURL(url);
EXPECT_TRUE(!content.empty()) << "nav = " << nav_;
CefRefPtr<CefStreamReader> stream =
CefStreamReader::CreateForData(
static_cast<void*>(const_cast<char*>(content.c_str())),
content.length());
return new CefStreamResourceHandler("text/html", stream);
}
bool OnBeforeBrowse(CefRefPtr<CefBrowser> browser,
CefRefPtr<CefFrame> frame,
CefRefPtr<CefRequest> request,
bool is_redirect) override {
EXPECT_TRUE(
expectations_->OnBeforeBrowse(browser, frame, request->GetURL())) <<
"nav = " << nav_;
return false;
}
void OnLoadingStateChange(CefRefPtr<CefBrowser> browser,
bool isLoading,
bool canGoBack,
bool canGoForward) override {
EXPECT_TRUE(expectations_->OnLoadingStateChange(browser, isLoading)) <<
"isLoading = " << isLoading << ", nav = " << nav_;;
}
void OnLoadStart(CefRefPtr<CefBrowser> browser,
CefRefPtr<CefFrame> frame,
TransitionType transition_type) override {
EXPECT_TRUE(expectations_->OnLoadStart(browser, frame)) << "nav = " << nav_;
}
void OnLoadEnd(CefRefPtr<CefBrowser> browser,
CefRefPtr<CefFrame> frame,
int httpStatusCode) override {
EXPECT_TRUE(expectations_->OnLoadEnd(browser, frame)) << "nav = " << nav_;
}
bool OnProcessMessageReceived(
CefRefPtr<CefBrowser> browser,
CefProcessId source_process,
CefRefPtr<CefProcessMessage> message) override {
if (message->GetName().ToString() == kFrameNavMsg) {
// Test that the renderer side succeeded.
CefRefPtr<CefListValue> args = message->GetArgumentList();
EXPECT_TRUE(args.get());
EXPECT_TRUE(expectations_->OnRendererComplete(browser,
args->GetInt(0), args->GetBool(1))) << "nav = " << nav_;
return true;
}
// Message not handled.
return false;
}
void DestroyTest() override {
if (got_destroyed_)
return;
got_destroyed_.yes();
// The expectations should have been tested already.
EXPECT_FALSE(expectations_.get());
// Test that factory conditions we met.
EXPECT_TRUE(factory_->Finalize()) << "nav = " << nav_;
TestHandler::DestroyTest();
}
int nav_;
TrackCallback got_destroyed_;
scoped_ptr<FrameNavExpectationsFactoryBrowser> factory_;
scoped_ptr<FrameNavExpectationsBrowser> expectations_;
IMPLEMENT_REFCOUNTING(FrameNavTestHandler);
};
// Helper for defining frame tests.
#define FRAME_TEST(name, factory_id) \
TEST(FrameTest, name) { \
CefRefPtr<FrameNavTestHandler> handler = \
new FrameNavTestHandler(factory_id); \
handler->ExecuteTest(); \
ReleaseAndWaitForDestructor(handler); \
}
// Browser process expectations for a single navigation.
class FrameNavExpectationsBrowserSingleNav :
public FrameNavExpectationsBrowser {
public:
explicit FrameNavExpectationsBrowserSingleNav(int nav)
: FrameNavExpectationsBrowser(nav) {
}
~FrameNavExpectationsBrowserSingleNav() override {
EXPECT_TRUE(got_finalize_);
}
bool OnLoadingStateChange(CefRefPtr<CefBrowser> browser,
bool isLoading) override {
if (isLoading) {
EXPECT_FALSE(got_loading_state_change_start_);
got_loading_state_change_start_.yes();
} else {
EXPECT_FALSE(got_loading_state_change_end_);
got_loading_state_change_end_.yes();
SignalCompleteIfDone(browser);
}
return true;
}
bool OnLoadStart(CefRefPtr<CefBrowser> browser,
CefRefPtr<CefFrame> frame) override {
EXPECT_FALSE(got_load_start_);
got_load_start_.yes();
return true;
}
bool OnLoadEnd(CefRefPtr<CefBrowser> browser,
CefRefPtr<CefFrame> frame) override {
EXPECT_FALSE(got_load_end_);
got_load_end_.yes();
SignalCompleteIfDone(browser);
return true;
}
bool OnAfterCreated(CefRefPtr<CefBrowser> browser) override {
EXPECT_FALSE(got_after_created_);
got_after_created_.yes();
return true;
}
bool OnBeforeBrowse(CefRefPtr<CefBrowser> browser,
CefRefPtr<CefFrame> frame,
const std::string& url) override {
EXPECT_FALSE(got_before_browse_);
got_before_browse_.yes();
return true;
}
bool GetResourceHandler(CefRefPtr<CefBrowser> browser,
CefRefPtr<CefFrame> frame) override {
EXPECT_FALSE(got_get_resource_handler_);
got_get_resource_handler_.yes();
return true;
}
bool OnRendererComplete(CefRefPtr<CefBrowser> browser,
int renderer_nav,
bool renderer_result) override {
EXPECT_EQ(nav(), renderer_nav);
EXPECT_TRUE(renderer_result);
EXPECT_FALSE(got_renderer_done_);
got_renderer_done_.yes();
SignalCompleteIfDone(browser);
return true;
}
bool Finalize() override {
V_DECLARE();
V_EXPECT_TRUE(got_load_start_);
V_EXPECT_TRUE(got_load_end_);
V_EXPECT_TRUE(got_loading_state_change_start_);
V_EXPECT_TRUE(got_loading_state_change_end_);
V_EXPECT_TRUE(got_renderer_done_);
V_EXPECT_TRUE(got_after_created_);
V_EXPECT_TRUE(got_before_browse_);
V_EXPECT_TRUE(got_get_resource_handler_);
V_EXPECT_FALSE(got_finalize_);
got_finalize_.yes();
V_RETURN();
}
private:
void SignalCompleteIfDone(CefRefPtr<CefBrowser> browser) {
if (got_renderer_done_ && got_load_end_ && got_loading_state_change_end_)
SignalComplete(browser);
}
TrackCallback got_load_start_;
TrackCallback got_load_end_;
TrackCallback got_loading_state_change_start_;
TrackCallback got_loading_state_change_end_;
TrackCallback got_renderer_done_;
TrackCallback got_after_created_;
TrackCallback got_before_browse_;
TrackCallback got_get_resource_handler_;
TrackCallback got_finalize_;
};
// Renderer process expectations for a single navigation.
class FrameNavExpectationsRendererSingleNav :
public FrameNavExpectationsRenderer {
public:
explicit FrameNavExpectationsRendererSingleNav(int nav)
: FrameNavExpectationsRenderer(nav) {
}
~FrameNavExpectationsRendererSingleNav() override {
EXPECT_TRUE(got_finalize_);
}
bool OnLoadingStateChange(CefRefPtr<CefBrowser> browser,
bool isLoading) override {
if (isLoading) {
EXPECT_FALSE(got_loading_state_change_start_);
got_loading_state_change_start_.yes();
} else {
EXPECT_FALSE(got_loading_state_change_end_);
got_loading_state_change_end_.yes();
SignalCompleteIfDone(browser);
}
return true;
}
bool OnLoadStart(CefRefPtr<CefBrowser> browser,
CefRefPtr<CefFrame> frame) override {
EXPECT_FALSE(got_load_start_);
got_load_start_.yes();
return true;
}
bool OnLoadEnd(CefRefPtr<CefBrowser> browser,
CefRefPtr<CefFrame> frame) override {
EXPECT_FALSE(got_load_end_);
got_load_end_.yes();
SignalCompleteIfDone(browser);
return true;
}
bool OnBeforeNavigation(CefRefPtr<CefBrowser> browser,
CefRefPtr<CefFrame> frame) override {
EXPECT_FALSE(got_before_navigation_);
got_before_navigation_.yes();
return true;
}
bool Finalize() override {
V_DECLARE();
V_EXPECT_TRUE(got_load_start_);
V_EXPECT_TRUE(got_load_end_);
V_EXPECT_TRUE(got_loading_state_change_start_);
V_EXPECT_TRUE(got_loading_state_change_end_);
V_EXPECT_TRUE(got_before_navigation_);
V_EXPECT_FALSE(got_finalize_);
got_finalize_.yes();
V_RETURN();
}
private:
void SignalCompleteIfDone(CefRefPtr<CefBrowser> browser) {
if (got_load_end_ && got_loading_state_change_end_)
SignalComplete(browser);
}
TrackCallback got_load_start_;
TrackCallback got_load_end_;
TrackCallback got_loading_state_change_start_;
TrackCallback got_loading_state_change_end_;
TrackCallback got_before_navigation_;
TrackCallback got_finalize_;
};
// Test that the single nav harness works.
class FrameNavExpectationsBrowserTestSingleNavHarness :
public FrameNavExpectationsBrowserSingleNav {
public:
typedef FrameNavExpectationsBrowserSingleNav parent;
explicit FrameNavExpectationsBrowserTestSingleNavHarness(int nav)
: parent(nav) {
}
~FrameNavExpectationsBrowserTestSingleNavHarness() override {
EXPECT_TRUE(got_finalize_);
}
std::string GetMainURL() override {
EXPECT_FALSE(got_get_main_url_);
got_get_main_url_.yes();
return kFrameNavOrigin0;
}
std::string GetContentForURL(const std::string& url) override {
EXPECT_FALSE(got_get_content_for_url_);
got_get_content_for_url_.yes();
EXPECT_STREQ(kFrameNavOrigin0, url.c_str());
return "<html><body>Nav</body></html>";
}
bool Finalize() override {
EXPECT_FALSE(got_finalize_);
got_finalize_.yes();
V_DECLARE();
V_EXPECT_TRUE(got_get_main_url_);
V_EXPECT_TRUE(got_get_content_for_url_);
V_EXPECT_TRUE(parent::Finalize());
V_RETURN();
}
private:
TrackCallback got_get_main_url_;
TrackCallback got_get_content_for_url_;
TrackCallback got_finalize_;
};
class FrameNavExpectationsRendererTestSingleNavHarness :
public FrameNavExpectationsRendererSingleNav {
public:
typedef FrameNavExpectationsRendererSingleNav parent;
explicit FrameNavExpectationsRendererTestSingleNavHarness(int nav)
: parent(nav) {
}
~FrameNavExpectationsRendererTestSingleNavHarness() override {
EXPECT_TRUE(got_finalize_);
}
bool Finalize() override {
EXPECT_FALSE(got_finalize_);
got_finalize_.yes();
return parent::Finalize();
}
private:
TrackCallback got_finalize_;
};
class FrameNavExpectationsFactoryBrowserTestSingleNavHarness :
public FrameNavExpectationsFactoryBrowser {
public:
FrameNavExpectationsFactoryBrowserTestSingleNavHarness() {}
~FrameNavExpectationsFactoryBrowserTestSingleNavHarness() override {
EXPECT_TRUE(got_finalize_);
}
FrameNavFactoryId GetID() const override {
return FNF_ID_SINGLE_NAV_HARNESS;
}
bool HasMoreNavigations() const override {
EXPECT_FALSE(got_get_browser_navigation_count_);
got_get_browser_navigation_count_.yes();
return false;
}
bool Finalize() override {
EXPECT_FALSE(got_finalize_);
got_finalize_.yes();
V_DECLARE();
V_EXPECT_TRUE(got_get_browser_navigation_count_);
V_EXPECT_TRUE(got_create_);
V_RETURN();
}
protected:
scoped_ptr<FrameNavExpectationsBrowser> Create(int nav) override {
EXPECT_FALSE(got_create_);
got_create_.yes();
return scoped_ptr<FrameNavExpectationsBrowser>(
new FrameNavExpectationsBrowserTestSingleNavHarness(nav));
}
private:
mutable TrackCallback got_get_browser_navigation_count_;
TrackCallback got_create_;
TrackCallback got_finalize_;
};
class FrameNavExpectationsFactoryRendererTestSingleNavHarness :
public FrameNavExpectationsFactoryRenderer {
public:
FrameNavExpectationsFactoryRendererTestSingleNavHarness() {}
FrameNavFactoryId GetID() const override {
return FNF_ID_SINGLE_NAV_HARNESS;
}
protected:
scoped_ptr<FrameNavExpectationsRenderer> Create(int nav) override {
return scoped_ptr<FrameNavExpectationsRenderer>(
new FrameNavExpectationsRendererTestSingleNavHarness(nav));
}
};
} // namespace
// Test that the single nav harness works.
FRAME_TEST(SingleNavHarness, FNF_ID_SINGLE_NAV_HARNESS)
namespace {
bool VerifySingleBrowserFrame(CefRefPtr<CefBrowser> browser,
CefRefPtr<CefFrame> frame,
bool frame_should_exist,
const std::string& expected_url) {
V_DECLARE();
V_EXPECT_TRUE(frame.get());
V_EXPECT_TRUE(frame->IsValid());
if (frame_should_exist) {
V_EXPECT_TRUE(frame->GetIdentifier() >= 0);
} else {
V_EXPECT_TRUE(frame->GetIdentifier() == -4); // kInvalidFrameId
}
V_EXPECT_TRUE(frame->IsValid());
V_EXPECT_TRUE(frame->IsMain());
V_EXPECT_TRUE(frame->IsFocused());
V_EXPECT_FALSE(frame->GetParent().get());
V_EXPECT_TRUE(frame->GetName().empty());
V_EXPECT_TRUE(browser->GetIdentifier() ==
frame->GetBrowser()->GetIdentifier());
const std::string& frame_url = frame->GetURL();
V_EXPECT_TRUE(frame_url == expected_url) << "frame_url = " << frame_url <<
", expected_url = " << expected_url;
V_RETURN();
}
bool VerifySingleBrowserFrames(CefRefPtr<CefBrowser> browser,
CefRefPtr<CefFrame> frame,
bool frame_should_exist,
const std::string& expected_url) {
V_DECLARE();
V_EXPECT_TRUE(browser.get());
// |frame| may be NULL for callbacks that don't specify one.
if (frame.get()) {
V_EXPECT_TRUE(VerifySingleBrowserFrame(browser, frame,
frame_should_exist, expected_url));
}
CefRefPtr<CefFrame> main_frame = browser->GetMainFrame();
V_EXPECT_TRUE(VerifySingleBrowserFrame(browser, main_frame,
frame_should_exist, expected_url));
CefRefPtr<CefFrame> focused_frame = browser->GetFocusedFrame();
V_EXPECT_TRUE(VerifySingleBrowserFrame(browser, focused_frame,
frame_should_exist, expected_url));
size_t frame_count = browser->GetFrameCount();
if (frame_should_exist) {
V_EXPECT_TRUE(frame_count == 1U);
std::vector<int64> identifiers;
browser->GetFrameIdentifiers(identifiers);
V_EXPECT_TRUE(identifiers.size() == 1U);
if (identifiers.size() == 1U) {
V_EXPECT_TRUE(identifiers[0] == main_frame->GetIdentifier());
V_EXPECT_TRUE(identifiers[0] == focused_frame->GetIdentifier());
}
std::vector<CefString> names;
browser->GetFrameNames(names);
V_EXPECT_TRUE(names.size() == 1U);
if (names.size() == 1U) {
V_EXPECT_TRUE(names[0].ToString() == main_frame->GetName().ToString());
V_EXPECT_TRUE(names[0].ToString() == focused_frame->GetName().ToString());
}
} else {
V_EXPECT_TRUE(frame_count == 0U);
}
V_RETURN();
}
// Test that single navigation works.
class FrameNavExpectationsBrowserTestSingleNav :
public FrameNavExpectationsBrowserSingleNav {
public:
typedef FrameNavExpectationsBrowserSingleNav parent;
explicit FrameNavExpectationsBrowserTestSingleNav(int nav)
: parent(nav) {
}
std::string GetMainURL() override {
return kFrameNavOrigin0;
}
std::string GetContentForURL(const std::string& url) override {
return "<html><body>Nav</body></html>";
}
bool OnLoadingStateChange(CefRefPtr<CefBrowser> browser,
bool isLoading) override {
V_DECLARE();
if (isLoading) {
// No frame exists before the first load.
V_EXPECT_TRUE(VerifySingleBrowserFrames(browser, NULL, false,
std::string()));
} else {
V_EXPECT_TRUE(VerifySingleBrowserFrames(browser, NULL, true,
kFrameNavOrigin0));
}
V_EXPECT_TRUE(parent::OnLoadingStateChange(browser, isLoading));
V_RETURN();
}
bool OnLoadStart(CefRefPtr<CefBrowser> browser,
CefRefPtr<CefFrame> frame) override {
V_DECLARE();
V_EXPECT_TRUE(VerifySingleBrowserFrames(browser, frame, true,
kFrameNavOrigin0));
V_EXPECT_TRUE(parent::OnLoadStart(browser, frame));
V_RETURN();
}
bool OnLoadEnd(CefRefPtr<CefBrowser> browser,
CefRefPtr<CefFrame> frame) override {
V_DECLARE();
V_EXPECT_TRUE(VerifySingleBrowserFrames(browser, frame, true,
kFrameNavOrigin0));
V_EXPECT_TRUE(parent::OnLoadEnd(browser, frame));
V_RETURN();
}
bool OnAfterCreated(CefRefPtr<CefBrowser> browser) override {
V_DECLARE();
V_EXPECT_TRUE(VerifySingleBrowserFrames(browser, NULL, false,
std::string()));
V_EXPECT_TRUE(parent::OnAfterCreated(browser));
V_RETURN();
}
bool OnBeforeBrowse(CefRefPtr<CefBrowser> browser,
CefRefPtr<CefFrame> frame,
const std::string& url) override {
V_DECLARE();
V_EXPECT_TRUE(VerifySingleBrowserFrames(browser, frame, true,
std::string()));
V_EXPECT_TRUE(parent::OnBeforeBrowse(browser, frame, url));
V_RETURN();
}
bool GetResourceHandler(CefRefPtr<CefBrowser> browser,
CefRefPtr<CefFrame> frame) override {
V_DECLARE();
V_EXPECT_TRUE(VerifySingleBrowserFrames(browser, frame, true,
std::string()));
V_EXPECT_TRUE(parent::GetResourceHandler(browser, frame));
V_RETURN();
}
bool OnRendererComplete(CefRefPtr<CefBrowser> browser,
int renderer_nav,
bool renderer_result) override {
return parent::OnRendererComplete(browser, renderer_nav, renderer_result);
}
bool Finalize() override {
return parent::Finalize();
}
};
class FrameNavExpectationsRendererTestSingleNav :
public FrameNavExpectationsRendererSingleNav {
public:
typedef FrameNavExpectationsRendererSingleNav parent;
explicit FrameNavExpectationsRendererTestSingleNav(int nav)
: parent(nav) {
}
bool OnLoadingStateChange(CefRefPtr<CefBrowser> browser,
bool isLoading) override {
V_DECLARE();
// A frame should always exist in the renderer process.
if (isLoading) {
V_EXPECT_TRUE(VerifySingleBrowserFrames(browser, NULL, true,
std::string()));
} else {
V_EXPECT_TRUE(VerifySingleBrowserFrames(browser, NULL, true,
kFrameNavOrigin0));
}
V_EXPECT_TRUE(parent::OnLoadingStateChange(browser, isLoading));
V_RETURN();
}
bool OnLoadStart(CefRefPtr<CefBrowser> browser,
CefRefPtr<CefFrame> frame) override {
V_DECLARE();
V_EXPECT_TRUE(VerifySingleBrowserFrames(browser, frame, true,
kFrameNavOrigin0));
V_EXPECT_TRUE(parent::OnLoadStart(browser, frame));
V_RETURN();
}
bool OnLoadEnd(CefRefPtr<CefBrowser> browser,
CefRefPtr<CefFrame> frame) override {
V_DECLARE();
V_EXPECT_TRUE(VerifySingleBrowserFrames(browser, frame, true,
kFrameNavOrigin0));
V_EXPECT_TRUE(parent::OnLoadEnd(browser, frame));
V_RETURN();
}
bool Finalize() override {
return parent::Finalize();
}
};
class FrameNavExpectationsFactoryBrowserTestSingleNav :
public FrameNavExpectationsFactoryBrowser {
public:
FrameNavExpectationsFactoryBrowserTestSingleNav() {}
FrameNavFactoryId GetID() const override {
return FNF_ID_SINGLE_NAV;
}
bool HasMoreNavigations() const override {
return false;
}
bool Finalize() override {
return true;
}
protected:
scoped_ptr<FrameNavExpectationsBrowser> Create(int nav) override {
return scoped_ptr<FrameNavExpectationsBrowser>(
new FrameNavExpectationsBrowserTestSingleNav(nav));
}
};
class FrameNavExpectationsFactoryRendererTestSingleNav :
public FrameNavExpectationsFactoryRenderer {
public:
FrameNavExpectationsFactoryRendererTestSingleNav() {}
FrameNavFactoryId GetID() const override {
return FNF_ID_SINGLE_NAV;
}
protected:
scoped_ptr<FrameNavExpectationsRenderer> Create(int nav) override {
return scoped_ptr<FrameNavExpectationsRenderer>(
new FrameNavExpectationsRendererTestSingleNav(nav));
}
};
} // namespace
// Test that single navigation works.
FRAME_TEST(SingleNav, FNF_ID_SINGLE_NAV)
namespace {
// Browser process expectations for a multiple navigations.
class FrameNavExpectationsBrowserMultiNav :
public FrameNavExpectationsBrowser {
public:
explicit FrameNavExpectationsBrowserMultiNav(int nav)
: FrameNavExpectationsBrowser(nav) {
}
~FrameNavExpectationsBrowserMultiNav() override {
EXPECT_TRUE(got_finalize_);
}
// Returns true if all navigation is done.
virtual bool IsNavigationDone() const =0;
bool OnLoadingStateChange(CefRefPtr<CefBrowser> browser,
bool isLoading) override {
if (!isLoading)
SignalCompleteIfDone(browser);
return true;
}
bool OnLoadEnd(CefRefPtr<CefBrowser> browser,
CefRefPtr<CefFrame> frame) override {
SignalCompleteIfDone(browser);
return true;
}
bool OnRendererComplete(CefRefPtr<CefBrowser> browser,
int renderer_nav,
bool renderer_result) override {
EXPECT_TRUE(renderer_result);
SignalCompleteIfDone(browser);
return true;
}
bool Finalize() override {
V_DECLARE();
V_EXPECT_FALSE(got_finalize_);
got_finalize_.yes();
V_RETURN();
}
private:
void SignalCompleteIfDone(CefRefPtr<CefBrowser> browser) {
if (IsNavigationDone())
SignalComplete(browser);
}
TrackCallback got_finalize_;
};
// Renderer process expectations for a multiple navigations.
class FrameNavExpectationsRendererMultiNav :
public FrameNavExpectationsRenderer {
public:
explicit FrameNavExpectationsRendererMultiNav(int nav)
: FrameNavExpectationsRenderer(nav) {
}
~FrameNavExpectationsRendererMultiNav() override {
EXPECT_TRUE(got_finalize_);
}
// Returns true if all navigation is done.
virtual bool IsNavigationDone() const =0;
bool OnLoadingStateChange(CefRefPtr<CefBrowser> browser,
bool isLoading) override {
if (!isLoading)
SignalCompleteIfDone(browser);
return true;
}
bool OnLoadEnd(CefRefPtr<CefBrowser> browser,
CefRefPtr<CefFrame> frame) override {
SignalCompleteIfDone(browser);
return true;
}
bool Finalize() override {
V_DECLARE();
V_EXPECT_FALSE(got_finalize_);
got_finalize_.yes();
V_RETURN();
}
private:
void SignalCompleteIfDone(CefRefPtr<CefBrowser> browser) {
if (IsNavigationDone())
SignalComplete(browser);
}
TrackCallback got_finalize_;
};
// Create a URL containing the nav number.
std::string GetMultiNavURL(const std::string& origin, int nav) {
std::stringstream ss;
ss << origin << "nav" << nav << ".html";
return ss.str();
}
// Extract the nav number from the URL.
int GetNavFromMultiNavURL(const std::string& url) {
const size_t start = url.find("/nav");
const size_t end = url.find(".html", start);
EXPECT_TRUE(start < end && start > 0U);
const std::string& nav = url.substr(start + 4, end - start - 4);
return atoi(nav.c_str());
}
// Extract the origin from the URL.
std::string GetOriginFromMultiNavURL(const std::string& url) {
const size_t pos = url.rfind("/");
EXPECT_TRUE(pos > 0U);
return url.substr(0, pos + 1);
}
// Test that the multi nav harness works.
class FrameNavExpectationsBrowserTestMultiNavHarness :
public FrameNavExpectationsBrowserMultiNav {
public:
typedef FrameNavExpectationsBrowserMultiNav parent;
explicit FrameNavExpectationsBrowserTestMultiNavHarness(int nav)
: parent(nav),
navigation_done_count_(0) {
}
~FrameNavExpectationsBrowserTestMultiNavHarness() override {
EXPECT_TRUE(got_finalize_);
}
std::string GetMainURL() override {
EXPECT_FALSE(got_get_main_url_);
got_get_main_url_.yes();
return GetMultiNavURL(kFrameNavOrigin0, nav());
}
std::string GetContentForURL(const std::string& url) override {
EXPECT_FALSE(got_get_content_for_url_);
got_get_content_for_url_.yes();
EXPECT_STREQ(GetMultiNavURL(kFrameNavOrigin0, nav()).c_str(), url.c_str());
return "<html><body>Nav</body></html>";
}
bool IsNavigationDone() const override {
navigation_done_count_++;
return got_load_state_change_done_ && got_load_end_ &&
got_renderer_complete_;
}
bool OnLoadingStateChange(CefRefPtr<CefBrowser> browser,
bool isLoading) override {
if (!isLoading) {
EXPECT_FALSE(got_load_state_change_done_);
got_load_state_change_done_.yes();
}
return parent::OnLoadingStateChange(browser, isLoading);
}
bool OnLoadEnd(CefRefPtr<CefBrowser> browser,
CefRefPtr<CefFrame> frame) override {
EXPECT_FALSE(got_load_end_);
got_load_end_.yes();
return parent::OnLoadEnd(browser, frame);
}
bool OnAfterCreated(CefRefPtr<CefBrowser> browser) override {
EXPECT_FALSE(got_on_after_created_);
got_on_after_created_.yes();
return parent::OnAfterCreated(browser);
}
bool OnRendererComplete(CefRefPtr<CefBrowser> browser,
int renderer_nav,
bool renderer_result) override {
EXPECT_FALSE(got_renderer_complete_);
got_renderer_complete_.yes();
EXPECT_EQ(nav(), renderer_nav);
return parent::OnRendererComplete(browser, renderer_nav, renderer_result);
}
bool Finalize() override {
EXPECT_FALSE(got_finalize_);
got_finalize_.yes();
V_DECLARE();
V_EXPECT_TRUE(got_get_main_url_);
V_EXPECT_TRUE(got_get_content_for_url_);
V_EXPECT_TRUE(got_load_state_change_done_);
V_EXPECT_TRUE(got_load_end_);
if (nav() == 0) {
V_EXPECT_TRUE(got_on_after_created_);
} else {
V_EXPECT_FALSE(got_on_after_created_);
}
V_EXPECT_TRUE(got_renderer_complete_);
V_EXPECT_TRUE(navigation_done_count_ == 3);
V_EXPECT_TRUE(parent::Finalize());
V_RETURN();
}
private:
TrackCallback got_get_main_url_;
TrackCallback got_get_content_for_url_;
TrackCallback got_load_state_change_done_;
TrackCallback got_load_end_;
TrackCallback got_on_after_created_;
TrackCallback got_renderer_complete_;
mutable int navigation_done_count_;
TrackCallback got_finalize_;
};
class FrameNavExpectationsRendererTestMultiNavHarness :
public FrameNavExpectationsRendererMultiNav {
public:
typedef FrameNavExpectationsRendererMultiNav parent;
explicit FrameNavExpectationsRendererTestMultiNavHarness(int nav)
: parent(nav),
navigation_done_count_(0) {
}
~FrameNavExpectationsRendererTestMultiNavHarness() override {
EXPECT_TRUE(got_finalize_);
}
bool IsNavigationDone() const override {
navigation_done_count_++;
return got_load_state_change_done_ && got_load_end_;
}
bool OnLoadingStateChange(CefRefPtr<CefBrowser> browser,
bool isLoading) override {
if (!isLoading) {
EXPECT_FALSE(got_load_state_change_done_);
got_load_state_change_done_.yes();
}
return parent::OnLoadingStateChange(browser, isLoading);
}
bool OnLoadEnd(CefRefPtr<CefBrowser> browser,
CefRefPtr<CefFrame> frame) override {
EXPECT_FALSE(got_load_end_);
got_load_end_.yes();
return parent::OnLoadEnd(browser, frame);
}
bool Finalize() override {
EXPECT_FALSE(got_finalize_);
got_finalize_.yes();
V_DECLARE();
V_EXPECT_TRUE(got_load_state_change_done_);
V_EXPECT_TRUE(got_load_end_);
V_EXPECT_TRUE(navigation_done_count_ == 2);
V_EXPECT_TRUE(parent::Finalize());
V_RETURN();
}
private:
TrackCallback got_load_state_change_done_;
TrackCallback got_load_end_;
mutable int navigation_done_count_;
TrackCallback got_finalize_;
};
class FrameNavExpectationsFactoryBrowserTestMultiNavHarness :
public FrameNavExpectationsFactoryBrowser {
public:
FrameNavExpectationsFactoryBrowserTestMultiNavHarness()
: get_browser_navigation_count_(0),
create_count_(0) {}
~FrameNavExpectationsFactoryBrowserTestMultiNavHarness() override {
EXPECT_TRUE(got_finalize_);
}
FrameNavFactoryId GetID() const override {
return FNF_ID_MULTI_NAV_HARNESS;
}
bool HasMoreNavigations() const override {
get_browser_navigation_count_++;
return (get_browser_navigation_count_ < kMaxMultiNavNavigations);
}
bool Finalize() override {
EXPECT_FALSE(got_finalize_);
got_finalize_.yes();
V_DECLARE();
V_EXPECT_TRUE(get_browser_navigation_count_ == kMaxMultiNavNavigations);
V_EXPECT_TRUE(create_count_ == kMaxMultiNavNavigations);
V_RETURN();
}
protected:
scoped_ptr<FrameNavExpectationsBrowser> Create(int nav) override {
create_count_++;
return scoped_ptr<FrameNavExpectationsBrowser>(
new FrameNavExpectationsBrowserTestMultiNavHarness(nav));
}
private:
mutable int get_browser_navigation_count_;
int create_count_;
TrackCallback got_finalize_;
};
class FrameNavExpectationsFactoryRendererTestMultiNavHarness :
public FrameNavExpectationsFactoryRenderer {
public:
FrameNavExpectationsFactoryRendererTestMultiNavHarness() {}
FrameNavFactoryId GetID() const override {
return FNF_ID_MULTI_NAV_HARNESS;
}
protected:
scoped_ptr<FrameNavExpectationsRenderer> Create(int nav) override {
return scoped_ptr<FrameNavExpectationsRenderer>(
new FrameNavExpectationsRendererTestMultiNavHarness(nav));
}
};
} // namespace
// Test that the multiple nav harness works.
FRAME_TEST(MultiNavHarness, FNF_ID_MULTI_NAV_HARNESS)
namespace {
// Test that multiple navigation works.
class FrameNavExpectationsBrowserTestMultiNav :
public FrameNavExpectationsBrowserMultiNav {
public:
typedef FrameNavExpectationsBrowserMultiNav parent;
explicit FrameNavExpectationsBrowserTestMultiNav(int nav)
: parent(nav) {
}
std::string GetMainURL() override {
return GetMultiNavURL(kFrameNavOrigin0, nav());
}
std::string GetContentForURL(const std::string& url) override {
return "<html><body>Nav</body></html>";
}
bool IsNavigationDone() const override {
return got_load_state_change_done_ && got_load_end_ &&
got_renderer_complete_;
}
bool OnLoadingStateChange(CefRefPtr<CefBrowser> browser,
bool isLoading) override {
if (!isLoading)
got_load_state_change_done_.yes();
V_DECLARE();
// A frame should exist in all cases except for the very first load.
if (isLoading && nav() == 0) {
V_EXPECT_TRUE(VerifySingleBrowserFrames(browser, NULL, false,
std::string()));
} else if (isLoading) {
// Expect the URL from the previous load.
V_EXPECT_TRUE(VerifySingleBrowserFrames(browser, NULL, true,
GetPreviousMainURL()));
} else {
V_EXPECT_TRUE(VerifySingleBrowserFrames(browser, NULL, true,
GetMainURL()));
}
V_EXPECT_TRUE(parent::OnLoadingStateChange(browser, isLoading));
V_RETURN();
}
bool OnLoadStart(CefRefPtr<CefBrowser> browser,
CefRefPtr<CefFrame> frame) override {
V_DECLARE();
V_EXPECT_TRUE(VerifySingleBrowserFrames(browser, frame, true,
GetMainURL()));
V_EXPECT_TRUE(parent::OnLoadStart(browser, frame));
V_RETURN();
}
bool OnLoadEnd(CefRefPtr<CefBrowser> browser,
CefRefPtr<CefFrame> frame) override {
got_load_end_.yes();
V_DECLARE();
V_EXPECT_TRUE(VerifySingleBrowserFrames(browser, frame, true,
GetMainURL()));
V_EXPECT_TRUE(parent::OnLoadEnd(browser, frame));
V_RETURN();
}
bool OnAfterCreated(CefRefPtr<CefBrowser> browser) override {
V_DECLARE();
V_EXPECT_TRUE(VerifySingleBrowserFrames(browser, NULL, false,
std::string()));
V_EXPECT_TRUE(parent::OnAfterCreated(browser));
V_RETURN();
}
bool OnBeforeBrowse(CefRefPtr<CefBrowser> browser,
CefRefPtr<CefFrame> frame,
const std::string& url) override {
V_DECLARE();
std::string expected_url;
if (nav() > 0)
expected_url = GetPreviousMainURL();
V_EXPECT_TRUE(VerifySingleBrowserFrames(browser, frame, true,
expected_url));
V_EXPECT_TRUE(parent::OnBeforeBrowse(browser, frame, url));
V_RETURN();
}
bool GetResourceHandler(CefRefPtr<CefBrowser> browser,
CefRefPtr<CefFrame> frame) override {
V_DECLARE();
std::string expected_url;
if (nav() > 0)
expected_url = GetPreviousMainURL();
V_EXPECT_TRUE(VerifySingleBrowserFrames(browser, frame, true,
expected_url));
V_EXPECT_TRUE(parent::GetResourceHandler(browser, frame));
V_RETURN();
}
bool OnRendererComplete(CefRefPtr<CefBrowser> browser,
int renderer_nav,
bool renderer_result) override {
got_renderer_complete_.yes();
V_DECLARE();
V_EXPECT_TRUE(nav() == renderer_nav);
V_EXPECT_TRUE(parent::OnRendererComplete(browser, renderer_nav,
renderer_result));
V_RETURN();
}
bool Finalize() override {
V_DECLARE();
V_EXPECT_TRUE(got_load_state_change_done_);
V_EXPECT_TRUE(got_load_end_);
V_EXPECT_TRUE(got_renderer_complete_);
V_EXPECT_TRUE(parent::Finalize());
V_RETURN();
}
private:
// Helper for VerifySingleBrowserFrames.
std::string GetPreviousMainURL() {
EXPECT_GT(nav(), 0);
return GetMultiNavURL(kFrameNavOrigin0, nav() - 1);
}
TrackCallback got_load_state_change_done_;
TrackCallback got_load_end_;
TrackCallback got_renderer_complete_;
};
class FrameNavExpectationsRendererTestMultiNav :
public FrameNavExpectationsRendererMultiNav {
public:
typedef FrameNavExpectationsRendererMultiNav parent;
explicit FrameNavExpectationsRendererTestMultiNav(int nav)
: parent(nav) {
}
bool IsNavigationDone() const override {
return got_load_state_change_done_ && got_load_end_;
}
bool OnLoadingStateChange(CefRefPtr<CefBrowser> browser,
bool isLoading) override {
if (!isLoading)
got_load_state_change_done_.yes();
V_DECLARE();
// A frame should always exist in the renderer process.
if (isLoading) {
std::string expected_url;
if (nav() > 0)
expected_url = GetPreviousMainURL();
V_EXPECT_TRUE(VerifySingleBrowserFrames(browser, NULL, true,
expected_url));
} else {
V_EXPECT_TRUE(VerifySingleBrowserFrames(browser, NULL, true,
GetMainURL()));
}
V_EXPECT_TRUE(parent::OnLoadingStateChange(browser, isLoading));
V_RETURN();
}
bool OnLoadStart(CefRefPtr<CefBrowser> browser,
CefRefPtr<CefFrame> frame) override {
V_DECLARE();
V_EXPECT_TRUE(VerifySingleBrowserFrames(browser, frame, true,
GetMainURL()));
V_EXPECT_TRUE(parent::OnLoadStart(browser, frame));
V_RETURN();
}
bool OnLoadEnd(CefRefPtr<CefBrowser> browser,
CefRefPtr<CefFrame> frame) override {
got_load_end_.yes();
V_DECLARE();
V_EXPECT_TRUE(VerifySingleBrowserFrames(browser, frame, true,
GetMainURL()));
V_EXPECT_TRUE(parent::OnLoadEnd(browser, frame));
V_RETURN();
}
bool Finalize() override {
V_DECLARE();
V_EXPECT_TRUE(got_load_state_change_done_);
V_EXPECT_TRUE(got_load_end_);
V_EXPECT_TRUE(parent::Finalize());
V_RETURN();
}
private:
// Helpers for calling VerifySingleBrowserFrames.
std::string GetMainURL() const {
return GetMultiNavURL(kFrameNavOrigin0, nav());
}
std::string GetPreviousMainURL() {
EXPECT_GT(nav(), 0);
return GetMultiNavURL(kFrameNavOrigin0, nav() - 1);
}
TrackCallback got_load_state_change_done_;
TrackCallback got_load_end_;
};
class FrameNavExpectationsFactoryBrowserTestMultiNav :
public FrameNavExpectationsFactoryBrowser {
public:
FrameNavExpectationsFactoryBrowserTestMultiNav()
: nav_count_(0) {}
FrameNavFactoryId GetID() const override {
return FNF_ID_MULTI_NAV;
}
bool HasMoreNavigations() const override {
return (nav_count_ < kMaxMultiNavNavigations);
}
bool Finalize() override {
V_DECLARE();
V_EXPECT_TRUE(nav_count_ == kMaxMultiNavNavigations);
V_RETURN();
}
protected:
scoped_ptr<FrameNavExpectationsBrowser> Create(int nav) override {
nav_count_++;
return scoped_ptr<FrameNavExpectationsBrowser>(
new FrameNavExpectationsBrowserTestMultiNav(nav));
}
private:
int nav_count_;
};
class FrameNavExpectationsFactoryRendererTestMultiNav :
public FrameNavExpectationsFactoryRenderer {
public:
FrameNavExpectationsFactoryRendererTestMultiNav() {}
FrameNavFactoryId GetID() const override {
return FNF_ID_MULTI_NAV;
}
protected:
scoped_ptr<FrameNavExpectationsRenderer> Create(int nav) override {
return scoped_ptr<FrameNavExpectationsRenderer>(
new FrameNavExpectationsRendererTestMultiNav(nav));
}
};
} // namespace
// Test that multiple navigation works.
FRAME_TEST(MultiNav, FNF_ID_MULTI_NAV)
namespace {
const char kFrame0Name[] = "";
const char kFrame1Name[] = "nav2";
const char kFrame2Name[] = "<!--framePath //nav2/<!--frame0-->-->";
bool VerifyBrowserIframe(CefRefPtr<CefBrowser> browser,
CefRefPtr<CefFrame> frame,
const std::string& origin,
int frame_number) {
V_DECLARE();
// frame0 contains frame1 contains frame2.
CefRefPtr<CefFrame> frame0, frame1, frame2;
CefRefPtr<CefFrame> frame0b, frame1b, frame2b;
int64 frame0id, frame1id, frame2id;
std::string frame0url, frame1url, frame2url;
// Find frames by name.
frame0 = browser->GetFrame(kFrame0Name);
V_EXPECT_TRUE(frame0.get());
frame1 = browser->GetFrame(kFrame1Name);
V_EXPECT_TRUE(frame1.get());
frame2 = browser->GetFrame(kFrame2Name);
V_EXPECT_TRUE(frame2.get());
// Verify that the name matches.
V_EXPECT_TRUE(frame0->GetName().ToString() == kFrame0Name);
V_EXPECT_TRUE(frame1->GetName().ToString() == kFrame1Name);
V_EXPECT_TRUE(frame2->GetName().ToString() == kFrame2Name);
// Verify that the URL matches.
frame0url = GetMultiNavURL(origin, 0);
V_EXPECT_TRUE(frame0->GetURL() == frame0url);
frame1url = GetMultiNavURL(origin, 1);
V_EXPECT_TRUE(frame1->GetURL() == frame1url);
frame2url = GetMultiNavURL(origin, 2);
V_EXPECT_TRUE(frame2->GetURL() == frame2url);
// Verify that the frame id is valid.
frame0id = frame0->GetIdentifier();
V_EXPECT_TRUE(frame0id > 0);
frame1id = frame1->GetIdentifier();
V_EXPECT_TRUE(frame1id > 0);
frame2id = frame2->GetIdentifier();
V_EXPECT_TRUE(frame2id > 0);
// Verify that the current frame has the correct id.
if (frame_number == 0) {
V_EXPECT_TRUE(frame->GetIdentifier() == frame0id);
} else if (frame_number == 1) {
V_EXPECT_TRUE(frame->GetIdentifier() == frame1id);
} else if (frame_number == 2) {
V_EXPECT_TRUE(frame->GetIdentifier() == frame2id);
}
// Find frames by id.
frame0b = browser->GetFrame(frame0->GetIdentifier());
V_EXPECT_TRUE(frame0b.get());
frame1b = browser->GetFrame(frame1->GetIdentifier());
V_EXPECT_TRUE(frame1b.get());
frame2b = browser->GetFrame(frame2->GetIdentifier());
V_EXPECT_TRUE(frame2b.get());
// Verify that the id matches.
V_EXPECT_TRUE(frame0b->GetIdentifier() == frame0id);
V_EXPECT_TRUE(frame1b->GetIdentifier() == frame1id);
V_EXPECT_TRUE(frame2b->GetIdentifier() == frame2id);
size_t frame_count = browser->GetFrameCount();
V_EXPECT_TRUE(frame_count == 3U) << "actual " << frame_count;
// Verify the GetFrameNames result.
std::vector<CefString> names;
browser->GetFrameNames(names);
V_EXPECT_TRUE(names.size() == 3U);
V_EXPECT_TRUE(names[0].ToString() == kFrame0Name);
V_EXPECT_TRUE(names[1].ToString() == kFrame1Name);
V_EXPECT_TRUE(names[2].ToString() == kFrame2Name);
// Verify the GetFrameIdentifiers result.
std::vector<int64> idents;
browser->GetFrameIdentifiers(idents);
V_EXPECT_TRUE(idents.size() == 3U);
V_EXPECT_TRUE(idents[0] == frame0->GetIdentifier());
V_EXPECT_TRUE(idents[1] == frame1->GetIdentifier());
V_EXPECT_TRUE(idents[2] == frame2->GetIdentifier());
// Verify parent hierarchy.
V_EXPECT_FALSE(frame0->GetParent().get());
V_EXPECT_TRUE(frame1->GetParent()->GetIdentifier() == frame0id);
V_EXPECT_TRUE(frame2->GetParent()->GetIdentifier() == frame1id);
V_RETURN();
}
// Test that nested iframes work.
class FrameNavExpectationsBrowserTestNestedIframes :
public FrameNavExpectationsBrowserMultiNav {
public:
typedef FrameNavExpectationsBrowserMultiNav parent;
FrameNavExpectationsBrowserTestNestedIframes(int nav, bool same_origin)
: parent(nav),
same_origin_(same_origin) {
// In the browser process we can rely on the |nav| value to determine the
// origin.
if (same_origin) {
origin_ = kFrameNavOrigin0;
} else switch (nav) {
case 0:
origin_ = kFrameNavOrigin0;
break;
case 1:
origin_ = kFrameNavOrigin1;
break;
case 2:
origin_ = kFrameNavOrigin2;
break;
default:
EXPECT_TRUE(false); // Not reached.
break;
}
}
std::string GetMainURL() override {
// Load the first (main) frame.
return GetMultiNavURL(origin_, 0);
}
std::string GetContentForURL(const std::string& url) override {
const int frame_number = GetNavFromMultiNavURL(url);
switch (frame_number) {
case 0:
// Frame 0. Contains a named iframe.
return "<html><body>Nav1<iframe src=\"" +
GetMultiNavURL(origin_, 1) +
"\" name=\"nav2\"></body></html>";
case 1:
// Frame 1. Contains an unnamed iframe.
return "<html><body>Nav2<iframe src=\"" +
GetMultiNavURL(origin_, 2) +
"\"></body></html>";
case 2:
// Frame 2.
return "<html><body>Nav3</body></html>";
default:
EXPECT_TRUE(false); // Not reached.
return "";
}
}
bool IsNavigationDone() const override {
return got_load_state_change_done_ && got_renderer_complete_ &&
got_load_end_[0] && got_load_end_[1] && got_load_end_[2];
}
bool OnBeforeBrowse(CefRefPtr<CefBrowser> browser,
CefRefPtr<CefFrame> frame,
const std::string& url) override {
V_DECLARE();
V_EXPECT_TRUE(frame.get());
const int frame_number = GetNavFromMultiNavURL(url);
if (frame_number == 0) {
// Main frame.
V_EXPECT_TRUE(frame->IsMain());
} else {
// Sub frame.
V_EXPECT_FALSE(frame->IsMain());
}
V_EXPECT_TRUE(parent::OnBeforeBrowse(browser, frame, url));
V_RETURN();
}
bool OnLoadingStateChange(CefRefPtr<CefBrowser> browser,
bool isLoading) override {
V_DECLARE();
V_EXPECT_FALSE(got_load_state_change_done_);
if (!isLoading) {
got_load_state_change_done_.yes();
}
V_EXPECT_TRUE(parent::OnLoadingStateChange(browser, isLoading));
V_RETURN();
}
bool OnLoadStart(CefRefPtr<CefBrowser> browser,
CefRefPtr<CefFrame> frame) override {
const int frame_number = GetNavFromMultiNavURL(frame->GetURL());
V_DECLARE();
V_EXPECT_FALSE(got_load_start_[frame_number]);
V_EXPECT_FALSE(got_load_end_[frame_number]);
// Notification should be received for parent frame before child frame.
if (frame_number == 0) {
V_EXPECT_FALSE(got_load_start_[1]);
V_EXPECT_FALSE(got_load_start_[2]);
} else if (frame_number == 1) {
V_EXPECT_TRUE(got_load_start_[0]);
V_EXPECT_FALSE(got_load_start_[2]);
} else if (frame_number == 2) {
V_EXPECT_TRUE(got_load_start_[0]);
V_EXPECT_TRUE(got_load_start_[1]);
} else {
V_EXPECT_TRUE(false); // Not reached.
}
got_load_start_[frame_number].yes();
V_EXPECT_TRUE(parent::OnLoadStart(browser, frame));
V_RETURN();
}
bool OnLoadEnd(CefRefPtr<CefBrowser> browser,
CefRefPtr<CefFrame> frame) override {
const int frame_number = GetNavFromMultiNavURL(frame->GetURL());
V_DECLARE();
V_EXPECT_TRUE(got_load_start_[frame_number]);
V_EXPECT_FALSE(got_load_end_[frame_number]);
// Notification should be received for child frame before parent frame.
if (frame_number == 0) {
V_EXPECT_TRUE(got_load_end_[1]);
V_EXPECT_TRUE(got_load_end_[2]);
} else if (frame_number == 1) {
V_EXPECT_FALSE(got_load_end_[0]);
V_EXPECT_TRUE(got_load_end_[2]);
} else if (frame_number == 2) {
V_EXPECT_FALSE(got_load_end_[0]);
V_EXPECT_FALSE(got_load_end_[1]);
} else {
V_EXPECT_TRUE(false); // Not reached.
}
V_EXPECT_TRUE(VerifyBrowserIframe(browser, frame, origin_, frame_number)) <<
"frame_number = " << frame_number;
got_load_end_[frame_number].yes();
V_EXPECT_TRUE(parent::OnLoadEnd(browser, frame));
V_RETURN();
}
bool OnRendererComplete(CefRefPtr<CefBrowser> browser,
int renderer_nav,
bool renderer_result) override {
V_DECLARE();
V_EXPECT_FALSE(got_renderer_complete_);
if (same_origin_) {
V_EXPECT_TRUE(renderer_nav == nav());
} else {
// Because each navigation is in a new renderer process.
V_EXPECT_TRUE(renderer_nav == 0);
}
got_renderer_complete_.yes();
V_EXPECT_TRUE(parent::OnRendererComplete(browser, renderer_nav,
renderer_result));
V_RETURN();
}
bool Finalize() override {
V_DECLARE();
V_EXPECT_TRUE(got_load_state_change_done_);
V_EXPECT_TRUE(got_load_start_[0]);
V_EXPECT_TRUE(got_load_start_[1]);
V_EXPECT_TRUE(got_load_start_[2]);
V_EXPECT_TRUE(got_load_end_[0]);
V_EXPECT_TRUE(got_load_end_[1]);
V_EXPECT_TRUE(got_load_end_[2]);
V_EXPECT_TRUE(got_renderer_complete_);
V_EXPECT_TRUE(parent::Finalize());
V_RETURN();
}
private:
bool same_origin_;
std::string origin_;
TrackCallback got_load_state_change_done_;
TrackCallback got_load_start_[3];
TrackCallback got_load_end_[3];
TrackCallback got_renderer_complete_;
};
class FrameNavExpectationsRendererTestNestedIframes :
public FrameNavExpectationsRendererMultiNav {
public:
typedef FrameNavExpectationsRendererMultiNav parent;
FrameNavExpectationsRendererTestNestedIframes(int nav, bool same_origin)
: parent(nav) {
if (same_origin)
origin_ = kFrameNavOrigin0;
}
bool IsNavigationDone() const override {
return got_load_state_change_done_ &&
got_load_end_[0] && got_load_end_[1] && got_load_end_[2];
}
bool OnLoadingStateChange(CefRefPtr<CefBrowser> browser,
bool isLoading) override {
V_DECLARE();
V_EXPECT_FALSE(got_load_state_change_done_);
if (!isLoading) {
got_load_state_change_done_.yes();
}
V_EXPECT_TRUE(parent::OnLoadingStateChange(browser, isLoading));
V_RETURN();
}
bool OnLoadStart(CefRefPtr<CefBrowser> browser,
CefRefPtr<CefFrame> frame) override {
if (origin_.empty()) {
// When navigating different origins we can't rely on the nav() value
// because each navigation creates a new renderer process. Get the origin
// by parsing the URL instead.
origin_ = GetOriginFromMultiNavURL(browser->GetMainFrame()->GetURL());
}
const int frame_number = GetNavFromMultiNavURL(frame->GetURL());
V_DECLARE();
V_EXPECT_FALSE(got_load_start_[frame_number]);
V_EXPECT_FALSE(got_load_end_[frame_number]);
// Notification should be received for parent frame before child frame.
if (frame_number == 0) {
V_EXPECT_FALSE(got_load_start_[1]);
V_EXPECT_FALSE(got_load_start_[2]);
} else if (frame_number == 1) {
V_EXPECT_TRUE(got_load_start_[0]);
V_EXPECT_FALSE(got_load_start_[2]);
} else if (frame_number == 2) {
V_EXPECT_TRUE(got_load_start_[0]);
V_EXPECT_TRUE(got_load_start_[1]);
}
got_load_start_[frame_number].yes();
V_EXPECT_TRUE(parent::OnLoadStart(browser, frame));
V_RETURN();
}
bool OnLoadEnd(CefRefPtr<CefBrowser> browser,
CefRefPtr<CefFrame> frame) override {
const int frame_number = GetNavFromMultiNavURL(frame->GetURL());
V_DECLARE();
V_EXPECT_TRUE(got_load_start_[frame_number]);
V_EXPECT_FALSE(got_load_end_[frame_number]);
// Notification should be received for child frame before parent frame.
if (frame_number == 0) {
V_EXPECT_TRUE(got_load_end_[1]);
V_EXPECT_TRUE(got_load_end_[2]);
} else if (frame_number == 1) {
V_EXPECT_FALSE(got_load_end_[0]);
V_EXPECT_TRUE(got_load_end_[2]);
} else if (frame_number == 2) {
V_EXPECT_FALSE(got_load_end_[0]);
V_EXPECT_FALSE(got_load_end_[1]);
}
V_EXPECT_TRUE(VerifyBrowserIframe(browser, frame, origin_, frame_number)) <<
"frame_number = " << frame_number;
got_load_end_[frame_number].yes();
V_EXPECT_TRUE(parent::OnLoadEnd(browser, frame));
V_RETURN();
}
bool Finalize() override {
V_DECLARE();
V_EXPECT_TRUE(got_load_state_change_done_);
V_EXPECT_TRUE(got_load_start_[0]);
V_EXPECT_TRUE(got_load_start_[1]);
V_EXPECT_TRUE(got_load_start_[2]);
V_EXPECT_TRUE(got_load_end_[0]);
V_EXPECT_TRUE(got_load_end_[1]);
V_EXPECT_TRUE(got_load_end_[2]);
V_EXPECT_TRUE(parent::Finalize());
V_RETURN();
}
private:
std::string origin_;
TrackCallback got_load_state_change_done_;
TrackCallback got_load_start_[3];
TrackCallback got_load_end_[3];
};
class FrameNavExpectationsFactoryBrowserTestNestedIframesSameOrigin :
public FrameNavExpectationsFactoryBrowser {
public:
FrameNavExpectationsFactoryBrowserTestNestedIframesSameOrigin()
: create_count_(0) {}
FrameNavFactoryId GetID() const override {
return FNF_ID_NESTED_IFRAMES_SAME_ORIGIN;
}
bool HasMoreNavigations() const override {
return (create_count_ < kMaxMultiNavNavigations);
}
bool Finalize() override {
V_DECLARE();
V_EXPECT_TRUE(create_count_ == kMaxMultiNavNavigations);
V_RETURN();
}
protected:
scoped_ptr<FrameNavExpectationsBrowser> Create(int nav) override {
create_count_++;
return scoped_ptr<FrameNavExpectationsBrowser>(
new FrameNavExpectationsBrowserTestNestedIframes(nav, true));
}
private:
int create_count_;
};
class FrameNavExpectationsFactoryRendererTestNestedIframesSameOrigin :
public FrameNavExpectationsFactoryRenderer {
public:
FrameNavExpectationsFactoryRendererTestNestedIframesSameOrigin() {}
FrameNavFactoryId GetID() const override {
return FNF_ID_NESTED_IFRAMES_SAME_ORIGIN;
}
protected:
scoped_ptr<FrameNavExpectationsRenderer> Create(int nav) override {
return scoped_ptr<FrameNavExpectationsRenderer>(
new FrameNavExpectationsRendererTestNestedIframes(nav, true));
}
};
} // namespace
// Test that nested iframes work.
FRAME_TEST(NestedIframesSameOrigin, FNF_ID_NESTED_IFRAMES_SAME_ORIGIN)
namespace {
class FrameNavExpectationsFactoryBrowserTestNestedIframesDiffOrigin :
public FrameNavExpectationsFactoryBrowser {
public:
FrameNavExpectationsFactoryBrowserTestNestedIframesDiffOrigin()
: create_count_(0) {}
FrameNavFactoryId GetID() const override {
return FNF_ID_NESTED_IFRAMES_DIFF_ORIGIN;
}
bool HasMoreNavigations() const override {
return (create_count_ < kMaxMultiNavNavigations);
}
bool Finalize() override {
V_DECLARE();
V_EXPECT_TRUE(create_count_ == kMaxMultiNavNavigations);
V_RETURN();
}
protected:
scoped_ptr<FrameNavExpectationsBrowser> Create(int nav) override {
create_count_++;
return scoped_ptr<FrameNavExpectationsBrowser>(
new FrameNavExpectationsBrowserTestNestedIframes(nav, false));
}
private:
int create_count_;
};
class FrameNavExpectationsFactoryRendererTestNestedIframesDiffOrigin :
public FrameNavExpectationsFactoryRenderer {
public:
FrameNavExpectationsFactoryRendererTestNestedIframesDiffOrigin() {}
FrameNavFactoryId GetID() const override {
return FNF_ID_NESTED_IFRAMES_DIFF_ORIGIN;
}
protected:
scoped_ptr<FrameNavExpectationsRenderer> Create(int nav) override {
return scoped_ptr<FrameNavExpectationsRenderer>(
new FrameNavExpectationsRendererTestNestedIframes(nav, false));
}
};
} // namespace
// Test that nested iframes work.
FRAME_TEST(NestedIframesDiffOrigin, FNF_ID_NESTED_IFRAMES_DIFF_ORIGIN)
namespace {
// Returns a new factory in the browser or renderer process. All factory types
// must be listed here.
// static
scoped_ptr<FrameNavExpectationsFactoryBrowser>
FrameNavExpectationsFactoryBrowser::FromID(FrameNavFactoryId id) {
scoped_ptr<FrameNavExpectationsFactoryBrowser> factory;
switch (id) {
case FNF_ID_SINGLE_NAV_HARNESS:
factory.reset(new FrameNavExpectationsFactoryBrowserTestSingleNavHarness);
break;
case FNF_ID_SINGLE_NAV:
factory.reset(new FrameNavExpectationsFactoryBrowserTestSingleNav);
break;
case FNF_ID_MULTI_NAV_HARNESS:
factory.reset(new FrameNavExpectationsFactoryBrowserTestMultiNavHarness);
break;
case FNF_ID_MULTI_NAV:
factory.reset(new FrameNavExpectationsFactoryBrowserTestMultiNav);
break;
case FNF_ID_NESTED_IFRAMES_SAME_ORIGIN:
factory.reset(
new FrameNavExpectationsFactoryBrowserTestNestedIframesSameOrigin);
break;
case FNF_ID_NESTED_IFRAMES_DIFF_ORIGIN:
factory.reset(
new FrameNavExpectationsFactoryBrowserTestNestedIframesDiffOrigin);
break;
default:
break;
}
EXPECT_TRUE(factory);
EXPECT_EQ(id, factory->GetID());
return factory.Pass();
}
// static
scoped_ptr<FrameNavExpectationsFactoryRenderer>
FrameNavExpectationsFactoryRenderer::FromID(FrameNavFactoryId id) {
scoped_ptr<FrameNavExpectationsFactoryRenderer> factory;
switch (id) {
case FNF_ID_SINGLE_NAV_HARNESS:
factory.reset(
new FrameNavExpectationsFactoryRendererTestSingleNavHarness);
break;
case FNF_ID_SINGLE_NAV:
factory.reset(new FrameNavExpectationsFactoryRendererTestSingleNav);
break;
case FNF_ID_MULTI_NAV_HARNESS:
factory.reset(new FrameNavExpectationsFactoryRendererTestMultiNavHarness);
break;
case FNF_ID_MULTI_NAV:
factory.reset(new FrameNavExpectationsFactoryRendererTestMultiNav);
break;
case FNF_ID_NESTED_IFRAMES_SAME_ORIGIN:
factory.reset(
new FrameNavExpectationsFactoryRendererTestNestedIframesSameOrigin);
break;
case FNF_ID_NESTED_IFRAMES_DIFF_ORIGIN:
factory.reset(
new FrameNavExpectationsFactoryRendererTestNestedIframesDiffOrigin);
break;
default:
break;
}
EXPECT_TRUE(factory);
EXPECT_EQ(id, factory->GetID());
return factory.Pass();
}
} // namespace
// Entry point for creating frame browser test objects.
// Called from client_app_delegates.cc.
void CreateFrameBrowserTests(ClientAppBrowser::DelegateSet& delegates) {
delegates.insert(new FrameNavBrowserTest);
}
// Entry point for creating frame renderer test objects.
// Called from client_app_delegates.cc.
void CreateFrameRendererTests(ClientAppRenderer::DelegateSet& delegates) {
delegates.insert(new FrameNavRendererTest);
}