| // 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 <list> |
| |
| #include "include/base/cef_bind.h" |
| #include "include/wrapper/cef_closure_task.h" |
| #include "tests/ceftests/routing_test_handler.h" |
| #include "tests/ceftests/test_handler.h" |
| #include "tests/gtest/include/gtest/gtest.h" |
| |
| namespace { |
| |
| // How it works: |
| // 1. Load kTitleUrl1 (title should be kTitleStr1) |
| // 2. Load kTitleUrl2 (title should be kTitleStr2) |
| // 3. History back to kTitleUrl1 (title should be kTitleStr1) |
| // 4. History forward to kTitleUrl2 (title should be kTitleStr2) |
| // 5. Set title via JavaScript (title should be kTitleStr3) |
| |
| const char kTitleUrl1[] = "http://tests-title/nav1.html"; |
| const char kTitleUrl2[] = "http://tests-title/nav2.html"; |
| const char kTitleStr1[] = "Title 1"; |
| const char kTitleStr2[] = "Title 2"; |
| const char kTitleStr3[] = "Title 3"; |
| |
| // Browser side. |
| class TitleTestHandler : public TestHandler { |
| public: |
| TitleTestHandler() |
| : step_(0), got_title_change_(false), got_loading_state_change_(false) {} |
| |
| void RunTest() override { |
| // Add the resources that we will navigate to/from. |
| AddResource(kTitleUrl1, |
| "<html><head><title>" + std::string(kTitleStr1) + |
| "</title></head>Nav1</html>", |
| "text/html"); |
| AddResource(kTitleUrl2, |
| "<html><head><title>" + std::string(kTitleStr2) + |
| "</title></head>Nav2" + |
| "<script>function setTitle() { window.document.title = '" + |
| std::string(kTitleStr3) + "'; }</script>" + "</html>", |
| "text/html"); |
| |
| // Create the browser. |
| CreateBrowser(kTitleUrl1); |
| |
| // Time out the test after a reasonable period of time. |
| SetTestTimeout(); |
| } |
| |
| void OnTitleChange(CefRefPtr<CefBrowser> browser, |
| const CefString& title) override { |
| // Ignore the 2nd OnTitleChange call which arrives after navigation |
| // completion. |
| if (got_title_change_) |
| return; |
| |
| std::string title_str = title; |
| if (step_ == 0 || step_ == 2) { |
| EXPECT_STREQ(kTitleStr1, title_str.c_str()); |
| } else if (step_ == 1 || step_ == 3) { |
| EXPECT_STREQ(kTitleStr2, title_str.c_str()); |
| } else if (step_ == 4) { |
| EXPECT_STREQ(kTitleStr3, title_str.c_str()); |
| } |
| |
| got_title_[step_].yes(); |
| |
| if (step_ == 4) { |
| DestroyTest(); |
| } else { |
| got_title_change_ = true; |
| NextIfReady(browser); |
| } |
| } |
| |
| void OnLoadingStateChange(CefRefPtr<CefBrowser> browser, |
| bool isLoading, |
| bool canGoBack, |
| bool canGoForward) override { |
| if (isLoading) |
| return; |
| |
| // Call NextIfReady asynchronously because an additional call to |
| // OnTitleChange will be triggered later in the current call stack due to |
| // navigation completion and we want that call to arrive before execution of |
| // NextIfReady. |
| got_loading_state_change_ = true; |
| CefPostTask(TID_UI, |
| base::Bind(&TitleTestHandler::NextIfReady, this, browser)); |
| } |
| |
| private: |
| void NextIfReady(CefRefPtr<CefBrowser> browser) { |
| if (!got_title_change_ || !got_loading_state_change_) |
| return; |
| |
| got_title_change_ = false; |
| got_loading_state_change_ = false; |
| |
| switch (step_++) { |
| case 0: |
| browser->GetMainFrame()->LoadURL(kTitleUrl2); |
| break; |
| case 1: |
| browser->GoBack(); |
| break; |
| case 2: |
| browser->GoForward(); |
| break; |
| case 3: |
| browser->GetMainFrame()->ExecuteJavaScript("setTitle()", kTitleUrl2, 0); |
| break; |
| default: |
| EXPECT_TRUE(false); // Not reached. |
| } |
| } |
| |
| void DestroyTest() override { |
| for (int i = 0; i < 5; ++i) |
| EXPECT_TRUE(got_title_[i]) << "step " << i; |
| |
| TestHandler::DestroyTest(); |
| } |
| |
| int step_; |
| |
| bool got_title_change_; |
| bool got_loading_state_change_; |
| |
| TrackCallback got_title_[5]; |
| |
| IMPLEMENT_REFCOUNTING(TitleTestHandler); |
| }; |
| |
| } // namespace |
| |
| // Test title notifications. |
| TEST(DisplayTest, Title) { |
| CefRefPtr<TitleTestHandler> handler = new TitleTestHandler(); |
| handler->ExecuteTest(); |
| ReleaseAndWaitForDestructor(handler); |
| } |
| |
| namespace { |
| |
| const char kAutoResizeUrl[] = "http://tests-display/auto-resize.html"; |
| |
| class AutoResizeTestHandler : public RoutingTestHandler { |
| public: |
| AutoResizeTestHandler() {} |
| |
| void RunTest() override { |
| // Add the resources that we will navigate to/from. |
| AddResource(kAutoResizeUrl, |
| "<html><head><style>" |
| "body {overflow:hidden;margin:0px;padding:0px;}" |
| "</style></head><body><div id=a>Content</div></body></html>", |
| "text/html"); |
| |
| // Create the browser. |
| CreateBrowser(kAutoResizeUrl); |
| |
| // Time out the test after a reasonable period of time. |
| SetTestTimeout(); |
| } |
| |
| void OnAfterCreated(CefRefPtr<CefBrowser> browser) override { |
| RoutingTestHandler::OnAfterCreated(browser); |
| browser->GetHost()->SetAutoResizeEnabled(true, CefSize(10, 10), |
| CefSize(500, 500)); |
| } |
| |
| bool OnAutoResize(CefRefPtr<CefBrowser> browser, |
| const CefSize& new_size) override { |
| if (new_size.width == 1064 && new_size.height == 576) { |
| // Ignore this initial resize that may or may not occur. |
| } else if (!got_auto_resize1_) { |
| got_auto_resize1_.yes(); |
| EXPECT_EQ(50, new_size.width); |
| EXPECT_EQ(18, new_size.height); |
| |
| // Trigger a resize. |
| browser->GetMainFrame()->ExecuteJavaScript( |
| "document.getElementById('a').innerText='New Content';", |
| kAutoResizeUrl, 0); |
| } else if (!got_auto_resize2_) { |
| got_auto_resize2_.yes(); |
| EXPECT_EQ(50, new_size.width); |
| EXPECT_EQ(36, new_size.height); |
| |
| // Disable resize notifications. |
| browser->GetHost()->SetAutoResizeEnabled(false, CefSize(), CefSize()); |
| |
| // There should be no more resize notifications. End the test after a |
| // short delay. |
| browser->GetMainFrame()->ExecuteJavaScript( |
| "document.getElementById('a').innerText='New Content Again';" |
| "var interval = setInterval(function() {" |
| "window.testQuery({request:'done'});clearInterval(interval);}, 50);", |
| kAutoResizeUrl, 0); |
| } else { |
| EXPECT_TRUE(false); // Not reached. |
| } |
| return true; |
| } |
| |
| bool OnQuery(CefRefPtr<CefBrowser> browser, |
| CefRefPtr<CefFrame> frame, |
| int64 query_id, |
| const CefString& request, |
| bool persistent, |
| CefRefPtr<Callback> callback) override { |
| EXPECT_STREQ("done", request.ToString().c_str()); |
| EXPECT_FALSE(got_done_message_); |
| got_done_message_.yes(); |
| DestroyTest(); |
| return true; |
| } |
| |
| void DestroyTest() override { |
| EXPECT_TRUE(got_auto_resize1_); |
| EXPECT_TRUE(got_auto_resize2_); |
| EXPECT_TRUE(got_done_message_); |
| TestHandler::DestroyTest(); |
| } |
| |
| private: |
| TrackCallback got_auto_resize1_; |
| TrackCallback got_auto_resize2_; |
| TrackCallback got_done_message_; |
| |
| IMPLEMENT_REFCOUNTING(AutoResizeTestHandler); |
| }; |
| |
| } // namespace |
| |
| // Test OnAutoResize notification. |
| TEST(DisplayTest, AutoResize) { |
| CefRefPtr<AutoResizeTestHandler> handler = new AutoResizeTestHandler(); |
| handler->ExecuteTest(); |
| ReleaseAndWaitForDestructor(handler); |
| } |
| |
| namespace { |
| |
| // Browser side. |
| class ConsoleTestHandler : public TestHandler { |
| public: |
| struct TestConfig { |
| // Use something other than 1 as |line| for testing. |
| explicit TestConfig(cef_log_severity_t message_level) |
| : level(message_level), |
| message("'Test Message'"), |
| expected_message("Test Message"), |
| source("http://tests-console-message/level.html"), |
| line(42) {} |
| |
| cef_log_severity_t level; |
| std::string message; |
| std::string expected_message; |
| std::string source; |
| int line; |
| std::string function; |
| }; |
| |
| ConsoleTestHandler(const TestConfig& config) : config_(config) {} |
| |
| void RunTest() override { |
| // Add the resources that will be used to print to console. |
| AddResource( |
| config_.source, |
| CreateResourceContent(config_.message, config_.function, config_.line), |
| "text/html"); |
| |
| // Create the browser. |
| CreateBrowser(config_.source); |
| |
| // Time out the test after a reasonable period of time. |
| SetTestTimeout(); |
| } |
| |
| void OnLoadingStateChange(CefRefPtr<CefBrowser> browser, |
| bool isLoading, |
| bool canGoBack, |
| bool canGoForward) override { |
| if (isLoading) |
| return; |
| |
| // Print console message after loading. |
| browser->GetMainFrame()->ExecuteJavaScript("printMessage()", config_.source, |
| 0); |
| } |
| |
| bool OnConsoleMessage(CefRefPtr<CefBrowser> browser, |
| cef_log_severity_t level, |
| const CefString& message, |
| const CefString& source, |
| int line) override { |
| EXPECT_EQ(config_.level, level); |
| EXPECT_EQ(config_.expected_message, message.ToString()); |
| EXPECT_EQ(config_.source, source.ToString()); |
| EXPECT_EQ(config_.line, line); |
| |
| TestHandler::DestroyTest(); |
| |
| return false; |
| } |
| |
| private: |
| std::string CreateResourceContent(const CefString& message, |
| const CefString& function, |
| int line) { |
| std::string content = "<html><script>function printMessage() { "; |
| for (int i = 1; i < line; ++i) { |
| // Add additional lines to test the |line| argument in |OnConsoleMessage|. |
| content += ";\n"; |
| } |
| content += "console." + function.ToString() + "(" + message.ToString() + |
| "); }</script></html>"; |
| |
| return content; |
| } |
| |
| TestConfig config_; |
| |
| IMPLEMENT_REFCOUNTING(ConsoleTestHandler); |
| }; |
| |
| } // namespace |
| |
| TEST(DisplayTest, OnConsoleMessageDebug) { |
| ConsoleTestHandler::TestConfig config(LOGSEVERITY_DEBUG); |
| config.function = "debug"; |
| |
| CefRefPtr<ConsoleTestHandler> handler = new ConsoleTestHandler(config); |
| handler->ExecuteTest(); |
| ReleaseAndWaitForDestructor(handler); |
| } |
| |
| TEST(DisplayTest, OnConsoleMessageCount) { |
| ConsoleTestHandler::TestConfig config(LOGSEVERITY_DEBUG); |
| config.function = "count"; |
| config.expected_message = "Test Message: 1"; |
| |
| CefRefPtr<ConsoleTestHandler> handler = new ConsoleTestHandler(config); |
| handler->ExecuteTest(); |
| ReleaseAndWaitForDestructor(handler); |
| } |
| |
| TEST(DisplayTest, OnConsoleMessageTimeEnd) { |
| ConsoleTestHandler::TestConfig config(LOGSEVERITY_WARNING); |
| config.function = "timeEnd"; |
| config.expected_message = "Timer 'Test Message' does not exist"; |
| |
| CefRefPtr<ConsoleTestHandler> handler = new ConsoleTestHandler(config); |
| handler->ExecuteTest(); |
| ReleaseAndWaitForDestructor(handler); |
| } |
| |
| TEST(DisplayTest, OnConsoleMessageInfo) { |
| ConsoleTestHandler::TestConfig config(LOGSEVERITY_INFO); |
| config.function = "info"; |
| |
| CefRefPtr<ConsoleTestHandler> handler = new ConsoleTestHandler(config); |
| handler->ExecuteTest(); |
| ReleaseAndWaitForDestructor(handler); |
| } |
| |
| TEST(DisplayTest, OnConsoleMessageLog) { |
| ConsoleTestHandler::TestConfig config(LOGSEVERITY_INFO); |
| config.function = "log"; |
| |
| CefRefPtr<ConsoleTestHandler> handler = new ConsoleTestHandler(config); |
| handler->ExecuteTest(); |
| ReleaseAndWaitForDestructor(handler); |
| } |
| |
| TEST(DisplayTest, OnConsoleMessageGroup) { |
| ConsoleTestHandler::TestConfig config(LOGSEVERITY_INFO); |
| config.function = "group"; |
| |
| CefRefPtr<ConsoleTestHandler> handler = new ConsoleTestHandler(config); |
| handler->ExecuteTest(); |
| ReleaseAndWaitForDestructor(handler); |
| } |
| |
| TEST(DisplayTest, OnConsoleMessageGroupCollapsed) { |
| ConsoleTestHandler::TestConfig config(LOGSEVERITY_INFO); |
| config.function = "groupCollapsed"; |
| |
| CefRefPtr<ConsoleTestHandler> handler = new ConsoleTestHandler(config); |
| handler->ExecuteTest(); |
| ReleaseAndWaitForDestructor(handler); |
| } |
| |
| TEST(DisplayTest, OnConsoleMessageGroupEnd) { |
| ConsoleTestHandler::TestConfig config(LOGSEVERITY_INFO); |
| config.function = "groupEnd"; |
| |
| CefRefPtr<ConsoleTestHandler> handler = new ConsoleTestHandler(config); |
| handler->ExecuteTest(); |
| ReleaseAndWaitForDestructor(handler); |
| } |
| |
| TEST(DisplayTest, OnConsoleMessageTable) { |
| ConsoleTestHandler::TestConfig config(LOGSEVERITY_INFO); |
| config.function = "table"; |
| config.message = "[1, 2, 3]"; |
| config.expected_message = "1,2,3"; |
| |
| CefRefPtr<ConsoleTestHandler> handler = new ConsoleTestHandler(config); |
| handler->ExecuteTest(); |
| ReleaseAndWaitForDestructor(handler); |
| } |
| |
| TEST(DisplayTest, OnConsoleMessageTrace) { |
| ConsoleTestHandler::TestConfig config(LOGSEVERITY_INFO); |
| config.function = "trace"; |
| config.message = ""; |
| config.expected_message = "console.trace"; |
| |
| CefRefPtr<ConsoleTestHandler> handler = new ConsoleTestHandler(config); |
| handler->ExecuteTest(); |
| ReleaseAndWaitForDestructor(handler); |
| } |
| |
| TEST(DisplayTest, OnConsoleMessageWarn) { |
| ConsoleTestHandler::TestConfig config(LOGSEVERITY_WARNING); |
| config.function = "warn"; |
| |
| CefRefPtr<ConsoleTestHandler> handler = new ConsoleTestHandler(config); |
| handler->ExecuteTest(); |
| ReleaseAndWaitForDestructor(handler); |
| } |
| |
| TEST(DisplayTest, OnConsoleMessageError) { |
| ConsoleTestHandler::TestConfig config(LOGSEVERITY_ERROR); |
| config.function = "error"; |
| |
| CefRefPtr<ConsoleTestHandler> handler = new ConsoleTestHandler(config); |
| handler->ExecuteTest(); |
| ReleaseAndWaitForDestructor(handler); |
| } |
| |
| TEST(DisplayTest, OnConsoleMessageAssert) { |
| ConsoleTestHandler::TestConfig config(LOGSEVERITY_ERROR); |
| config.function = "assert"; |
| config.message = "false"; |
| config.expected_message = "console.assert"; |
| |
| CefRefPtr<ConsoleTestHandler> handler = new ConsoleTestHandler(config); |
| handler->ExecuteTest(); |
| ReleaseAndWaitForDestructor(handler); |
| } |
| |
| namespace { |
| |
| const char kLoadinProgressUrl[] = "http://tests-display/loading-progress.html"; |
| |
| // Browser side. |
| class LoadingProgressTestHandler : public TestHandler { |
| public: |
| LoadingProgressTestHandler() {} |
| |
| void RunTest() override { |
| // Add the resources that we will navigate to/from. |
| AddResource(kLoadinProgressUrl, |
| "<html><head><style>" |
| "body {overflow:hidden;margin:0px;padding:0px;}" |
| "</style></head><body><div id=a>Content</div></body></html>", |
| "text/html"); |
| |
| // Create the browser. |
| CreateBrowser(kLoadinProgressUrl); |
| |
| // Time out the test after a reasonable period of time. |
| SetTestTimeout(); |
| } |
| |
| void OnLoadingStateChange(CefRefPtr<CefBrowser> browser, |
| bool isLoading, |
| bool canGoBack, |
| bool canGoForward) override { |
| if (isLoading) |
| return; |
| |
| DestroyTest(); |
| } |
| |
| void OnLoadingProgressChange(CefRefPtr<CefBrowser> browser, |
| double progress) override { |
| if (!got_loading_progress_change0_) { |
| got_loading_progress_change0_.yes(); |
| EXPECT_GE(progress, 0.0); |
| } else if (!got_loading_progress_change1_) { |
| got_loading_progress_change1_.yes(); |
| EXPECT_LE(progress, 1.0); |
| } |
| } |
| |
| void DestroyTest() override { |
| EXPECT_TRUE(got_loading_progress_change0_); |
| EXPECT_TRUE(got_loading_progress_change1_); |
| TestHandler::DestroyTest(); |
| } |
| |
| private: |
| TrackCallback got_loading_progress_change0_; |
| TrackCallback got_loading_progress_change1_; |
| |
| IMPLEMENT_REFCOUNTING(LoadingProgressTestHandler); |
| }; |
| |
| } // namespace |
| |
| // Test OnLoadingProgressChange notification. |
| TEST(DisplayTest, LoadingProgress) { |
| CefRefPtr<LoadingProgressTestHandler> handler = |
| new LoadingProgressTestHandler(); |
| handler->ExecuteTest(); |
| ReleaseAndWaitForDestructor(handler); |
| } |
