644 lines
22 KiB
C++
644 lines
22 KiB
C++
// Copyright (c) 2015 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/cef_pack_resources.h"
|
|
#include "include/cef_resource_bundle.h"
|
|
#include "include/wrapper/cef_closure_task.h"
|
|
#include "include/wrapper/cef_stream_resource_handler.h"
|
|
#include "tests/ceftests/routing_test_handler.h"
|
|
#include "tests/gtest/include/gtest/gtest.h"
|
|
#include "tests/shared/browser/client_app_browser.h"
|
|
#include "tests/shared/browser/resource_util.h"
|
|
|
|
namespace {
|
|
|
|
std::string GetDataResourceAsString(int resource_id) {
|
|
void* data;
|
|
size_t data_size;
|
|
if (CefResourceBundle::GetGlobal()->GetDataResource(resource_id, data,
|
|
data_size)) {
|
|
return std::string(static_cast<char*>(data), data_size);
|
|
}
|
|
return std::string();
|
|
}
|
|
|
|
// Browser-side app delegate.
|
|
class PluginBrowserTest : public client::ClientAppBrowser::Delegate {
|
|
public:
|
|
PluginBrowserTest() {}
|
|
|
|
void OnBeforeCommandLineProcessing(
|
|
CefRefPtr<client::ClientAppBrowser> app,
|
|
CefRefPtr<CefCommandLine> command_line) override {
|
|
// Allow all plugin loading by default.
|
|
command_line->AppendSwitchWithValue("plugin-policy", "allow");
|
|
}
|
|
|
|
private:
|
|
IMPLEMENT_REFCOUNTING(PluginBrowserTest);
|
|
};
|
|
|
|
const char kPdfTestOrigin[] = "http://tests/";
|
|
const char kPdfHtmlUrl[] = "http://tests/pdf.html";
|
|
const char kPdfDirectUrl[] = "http://tests/pdf.pdf";
|
|
|
|
// Delay waiting for the plugin placeholder to load.
|
|
const int64 kPlaceholderLoadDelayMs = 1000;
|
|
|
|
// Delay waiting for iframe tests to load the PDF file.
|
|
#if defined(OS_LINUX)
|
|
const int64 kPdfLoadDelayMs = 7000;
|
|
#else
|
|
const int64 kPdfLoadDelayMs = 5000;
|
|
#endif
|
|
|
|
// Browser-side test handler.
|
|
class PluginTestHandler : public RoutingTestHandler,
|
|
public CefContextMenuHandler {
|
|
public:
|
|
enum Mode {
|
|
// No specified context or handler (implicitly uses the global context).
|
|
GLOBAL_DEFAULT,
|
|
|
|
// Global context with no handler.
|
|
GLOBAL_NO_HANDLER,
|
|
|
|
// Global context with handler that allows plugin load.
|
|
GLOBAL_ALLOW,
|
|
|
|
// Global context with handler that blocks plugin load. Then, load the
|
|
// plugin via the context menu.
|
|
GLOBAL_BLOCK_LOAD,
|
|
|
|
// Global context with handler that blocks plugin load. Then, hide the
|
|
// plugin via the context menu.
|
|
GLOBAL_BLOCK_HIDE,
|
|
|
|
// Global context with handler that disables plugin load. Then, hide the
|
|
// plugin via the context menu.
|
|
GLOBAL_DISABLE_HIDE,
|
|
|
|
// Global context with handler that removes the plugin from the
|
|
// `navigator.plugins` list and consequently disables plugin load.
|
|
GLOBAL_NO_LIST,
|
|
|
|
// Custom context with no handler.
|
|
CUSTOM_NO_HANDLER,
|
|
|
|
// Custom context with handler that allows plugin load.
|
|
CUSTOM_ALLOW,
|
|
|
|
// Custom context with handler that blocks plugin load. Then, load the
|
|
// plugin via the context menu.
|
|
CUSTOM_BLOCK_LOAD,
|
|
|
|
// Custom context with handler that blocks plugin load. Then, hide the
|
|
// plugin via the context menu.
|
|
CUSTOM_BLOCK_HIDE,
|
|
|
|
// Custom context with handler that disables plugin load. Then, hide the
|
|
// plugin via the context menu.
|
|
CUSTOM_DISABLE_HIDE,
|
|
|
|
// Custom context with handler that removes the plugin from the
|
|
// `navigator.plugins` list and consequently disables plugin load.
|
|
CUSTOM_NO_LIST,
|
|
};
|
|
|
|
class RequestContextHandler : public CefRequestContextHandler {
|
|
public:
|
|
explicit RequestContextHandler(PluginTestHandler* handler)
|
|
: handler_(handler) {}
|
|
|
|
bool OnBeforePluginLoad(const CefString& mime_type,
|
|
const CefString& plugin_url,
|
|
bool is_main_frame,
|
|
const CefString& top_origin_url,
|
|
CefRefPtr<CefWebPluginInfo> plugin_info,
|
|
PluginPolicy* plugin_policy) override {
|
|
const std::string& mime_type_str = mime_type;
|
|
EXPECT_STREQ("application/pdf", mime_type_str.c_str());
|
|
EXPECT_STREQ("chrome-extension://mhjfbmdgcfjbbpaeojofohoefgiehjai/",
|
|
plugin_info->GetPath().ToString().c_str());
|
|
|
|
if (top_origin_url.empty()) {
|
|
if (!handler_->got_on_before_plugin_empty_origin_) {
|
|
// Checking for PDF support in the plugin frame (navigator.plugins
|
|
// listing, pdf load, etc).
|
|
EXPECT_EQ(handler_->HasDirectPluginLoad(), is_main_frame);
|
|
handler_->got_on_before_plugin_empty_origin_.yes();
|
|
} else if (handler_->HasNoList()) {
|
|
// When listing is disabled there should be an additional check in the
|
|
// main frame for the navigator.plugins listing.
|
|
if (!handler_->got_on_before_plugin_empty_origin2_) {
|
|
EXPECT_EQ(true, is_main_frame);
|
|
handler_->got_on_before_plugin_empty_origin2_.yes();
|
|
} else {
|
|
NOTREACHED();
|
|
}
|
|
}
|
|
|
|
if (handler_->HasNoList()) {
|
|
// Remove the PDF plugin from the `navigator.plugins` list.
|
|
*plugin_policy = PLUGIN_POLICY_DISABLE;
|
|
return true;
|
|
}
|
|
|
|
// Ignore requests for building the plugin list.
|
|
return false;
|
|
}
|
|
|
|
// Should only get requests for the test origin.
|
|
EXPECT_STREQ(kPdfTestOrigin, top_origin_url.ToString().c_str());
|
|
|
|
if (!handler_->got_on_before_plugin_load_pdf_)
|
|
handler_->got_on_before_plugin_load_pdf_.yes();
|
|
else
|
|
NOTREACHED();
|
|
|
|
if (handler_->HasAllow()) {
|
|
*plugin_policy = PLUGIN_POLICY_ALLOW;
|
|
return true;
|
|
} else if (handler_->HasBlock()) {
|
|
*plugin_policy = PLUGIN_POLICY_BLOCK;
|
|
return true;
|
|
} else if (handler_->HasDisable()) {
|
|
*plugin_policy = PLUGIN_POLICY_DISABLE;
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
void Detach() { handler_ = NULL; }
|
|
|
|
private:
|
|
PluginTestHandler* handler_;
|
|
|
|
IMPLEMENT_REFCOUNTING(RequestContextHandler);
|
|
};
|
|
|
|
PluginTestHandler(Mode mode, const std::string& url)
|
|
: mode_(mode), url_(url) {}
|
|
|
|
// Loading the PDF directly in the main frame instead of a sub-frame.
|
|
bool HasDirectPluginLoad() const { return url_ == kPdfDirectUrl; }
|
|
|
|
// Has a specified RequestContext but not necessarily a custom handler.
|
|
bool HasRequestContext() const { return mode_ != GLOBAL_DEFAULT; }
|
|
|
|
// Has a specified RequestContext and custom handler.
|
|
bool HasRequestContextHandler() const {
|
|
return mode_ != GLOBAL_DEFAULT && mode_ != GLOBAL_NO_HANDLER &&
|
|
mode_ != CUSTOM_NO_HANDLER;
|
|
}
|
|
|
|
// Using the global request context, either directly or with a custom handler.
|
|
bool HasGlobalRequestContext() const {
|
|
return mode_ >= GLOBAL_DEFAULT && mode_ <= GLOBAL_NO_LIST;
|
|
}
|
|
|
|
// Should allow the plugin load via the custom handler.
|
|
bool HasAllow() const {
|
|
return mode_ == GLOBAL_ALLOW || mode_ == CUSTOM_ALLOW;
|
|
}
|
|
|
|
// Should block the plugin load via the custom handler.
|
|
bool HasBlock() const {
|
|
return mode_ == GLOBAL_BLOCK_LOAD || mode_ == GLOBAL_BLOCK_HIDE ||
|
|
mode_ == CUSTOM_BLOCK_LOAD || mode_ == CUSTOM_BLOCK_HIDE;
|
|
}
|
|
|
|
// Should disable the plugin load via the custom handler.
|
|
bool HasDisable() const {
|
|
return mode_ == GLOBAL_DISABLE_HIDE || mode_ == CUSTOM_DISABLE_HIDE;
|
|
}
|
|
|
|
// Should exclude the plugin from the `navigator.plugins` list.
|
|
bool HasNoList() const {
|
|
return mode_ == GLOBAL_NO_LIST || mode_ == CUSTOM_NO_LIST;
|
|
}
|
|
|
|
// Should load the plugin via the context menu.
|
|
bool HasContextLoad() const {
|
|
return mode_ == GLOBAL_BLOCK_LOAD || mode_ == CUSTOM_BLOCK_LOAD;
|
|
}
|
|
|
|
// Should hide the plugin via the context menu.
|
|
bool HasContextHide() const {
|
|
return mode_ == GLOBAL_BLOCK_HIDE || mode_ == GLOBAL_DISABLE_HIDE ||
|
|
mode_ == CUSTOM_BLOCK_HIDE || mode_ == CUSTOM_DISABLE_HIDE;
|
|
}
|
|
|
|
std::string GetPluginNode() const {
|
|
return "document.getElementsByTagName('embed')[0]";
|
|
}
|
|
|
|
void WaitForNavigatorPlugins(CefRefPtr<CefFrame> frame) const {
|
|
// Test if the `navigator.plugins` list includes the PDF extension.
|
|
const std::string& code =
|
|
" if (navigator.plugins['Chrome PDF Viewer'].filename == "
|
|
" 'mhjfbmdgcfjbbpaeojofohoefgiehjai') {"
|
|
" window.testQuery({request:'pdf_plugin_found'});"
|
|
"} else {"
|
|
" window.testQuery({request:'pdf_plugin_missing'});"
|
|
"}";
|
|
frame->ExecuteJavaScript(code, frame->GetURL(), 0);
|
|
}
|
|
|
|
void WaitForPlaceholderLoad(CefRefPtr<CefFrame> frame) {
|
|
// Waits for the placeholder to load.
|
|
CefPostDelayedTask(TID_UI,
|
|
base::Bind(&PluginTestHandler::TriggerContextMenu, this,
|
|
frame->GetBrowser()),
|
|
kPlaceholderLoadDelayMs);
|
|
}
|
|
|
|
void WaitForPlaceholderHide(CefRefPtr<CefFrame> frame) const {
|
|
// Waits for the placeholder to be hidden (style set to display:none).
|
|
// See PluginPlaceholderBase::HidePlugin.
|
|
const std::string& code =
|
|
"var plugin = " + GetPluginNode() +
|
|
";"
|
|
"var observer = new MutationObserver(function(mutations) {"
|
|
" mutations.forEach(function(mutationRecord) {"
|
|
" window.testQuery({request:'placeholder_hidden'});"
|
|
" observer.disconnect();"
|
|
" });"
|
|
"});"
|
|
"observer.observe(plugin, "
|
|
" { attributes : true, attributeFilter : ['style'] });";
|
|
frame->ExecuteJavaScript(code, frame->GetURL(), 0);
|
|
}
|
|
|
|
void WaitForPluginLoad(CefRefPtr<CefFrame> frame) {
|
|
if (url_ == kPdfHtmlUrl) {
|
|
// PDFScriptingAPI does not work with iframes (the LoadCallback will
|
|
// never be executed). Use a timeout instead.
|
|
if (got_context_menu_dismissed_) {
|
|
// After context menu display. Destroy the test.
|
|
CefPostDelayedTask(TID_UI,
|
|
base::Bind(&PluginTestHandler::DestroyTest, this),
|
|
kPdfLoadDelayMs);
|
|
} else {
|
|
// Trigger the context menu.
|
|
CefPostDelayedTask(TID_UI,
|
|
base::Bind(&PluginTestHandler::TriggerContextMenu,
|
|
this, frame->GetBrowser()),
|
|
kPdfLoadDelayMs);
|
|
}
|
|
return;
|
|
}
|
|
|
|
// Wait for the PDF file to load.
|
|
// See chrome/browser/pdf/pdf_extension_test_util.cc.
|
|
const std::string& scripting_api_js =
|
|
GetDataResourceAsString(IDR_PDF_PDF_SCRIPTING_API_JS);
|
|
EXPECT_TRUE(!scripting_api_js.empty());
|
|
frame->ExecuteJavaScript(scripting_api_js, frame->GetURL(), 0);
|
|
|
|
const std::string& code =
|
|
"var scriptingAPI = new PDFScriptingAPI(window, " + GetPluginNode() +
|
|
");"
|
|
"scriptingAPI.setLoadCallback(function(success) {"
|
|
" window.testQuery({request:'plugin_ready'});"
|
|
"});";
|
|
frame->ExecuteJavaScript(code, frame->GetURL(), 0);
|
|
}
|
|
|
|
void EndTest() {
|
|
CefPostTask(TID_UI, base::Bind(&PluginTestHandler::DestroyTest, this));
|
|
}
|
|
|
|
CefRefPtr<CefContextMenuHandler> GetContextMenuHandler() override {
|
|
return this;
|
|
}
|
|
|
|
void RunTest() override {
|
|
CefRefPtr<CefRequestContext> request_context;
|
|
|
|
if (HasRequestContext()) {
|
|
if (HasRequestContextHandler())
|
|
context_handler_ = new RequestContextHandler(this);
|
|
|
|
if (HasGlobalRequestContext()) {
|
|
// Use the global request context.
|
|
request_context = CefRequestContext::CreateContext(
|
|
CefRequestContext::GetGlobalContext(), context_handler_.get());
|
|
} else {
|
|
// Create the request context that will use an in-memory cache.
|
|
CefRequestContextSettings settings;
|
|
request_context =
|
|
CefRequestContext::CreateContext(settings, context_handler_.get());
|
|
}
|
|
}
|
|
|
|
// Create the browser.
|
|
CreateBrowser(url_, request_context);
|
|
|
|
// Time out the test after a reasonable period of time.
|
|
SetTestTimeout(5000 + kPdfLoadDelayMs);
|
|
}
|
|
|
|
CefRefPtr<CefResourceHandler> GetResourceHandler(
|
|
CefRefPtr<CefBrowser> browser,
|
|
CefRefPtr<CefFrame> frame,
|
|
CefRefPtr<CefRequest> request) override {
|
|
const std::string& url = request->GetURL();
|
|
if (url == kPdfHtmlUrl) {
|
|
CefRefPtr<CefStreamReader> stream =
|
|
client::GetBinaryResourceReader("pdf.html");
|
|
return new CefStreamResourceHandler("text/html", stream);
|
|
} else if (url == kPdfDirectUrl) {
|
|
CefRefPtr<CefStreamReader> stream =
|
|
client::GetBinaryResourceReader("pdf.pdf");
|
|
return new CefStreamResourceHandler("application/pdf", stream);
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
void OnLoadEnd(CefRefPtr<CefBrowser> browser,
|
|
CefRefPtr<CefFrame> frame,
|
|
int httpStatusCode) override {
|
|
bool is_pdf1 = false;
|
|
const std::string& url = frame->GetURL();
|
|
if (url == kPdfHtmlUrl) {
|
|
if (!got_on_load_end_html_)
|
|
got_on_load_end_html_.yes();
|
|
else
|
|
NOTREACHED();
|
|
} else if (url == kPdfDirectUrl) {
|
|
if (!got_on_load_end_pdf1_) {
|
|
got_on_load_end_pdf1_.yes();
|
|
is_pdf1 = true;
|
|
} else if (!got_on_load_end_pdf2_) {
|
|
got_on_load_end_pdf2_.yes();
|
|
} else {
|
|
NOTREACHED();
|
|
}
|
|
} else {
|
|
NOTREACHED();
|
|
}
|
|
|
|
if (HasNoList()) {
|
|
// If the plugin is not listed then the PDF documents will never load.
|
|
EXPECT_STREQ(kPdfHtmlUrl, url.c_str());
|
|
WaitForNavigatorPlugins(frame);
|
|
} else if (is_pdf1) {
|
|
// The first PDF document has loaded.
|
|
WaitForNavigatorPlugins(frame);
|
|
}
|
|
}
|
|
|
|
bool OnQuery(CefRefPtr<CefBrowser> browser,
|
|
CefRefPtr<CefFrame> frame,
|
|
int64 query_id,
|
|
const CefString& request,
|
|
bool persistent,
|
|
CefRefPtr<Callback> callback) override {
|
|
if (request == "pdf_plugin_found" || request == "pdf_plugin_missing") {
|
|
if (request == "pdf_plugin_found")
|
|
got_pdf_plugin_found_.yes();
|
|
else
|
|
got_pdf_plugin_missing_.yes();
|
|
|
|
if (HasNoList()) {
|
|
// The plugin will not load. End the test.
|
|
EndTest();
|
|
} else if (HasBlock() || HasDisable()) {
|
|
// Wait for the plugin placeholder for the first PDF file to load. The
|
|
// test will continue from OnQuery.
|
|
WaitForPlaceholderLoad(frame);
|
|
} else {
|
|
// Wait for the first PDF file to load.
|
|
WaitForPluginLoad(frame);
|
|
}
|
|
} else if (request == "placeholder_hidden") {
|
|
EXPECT_FALSE(got_placeholder_hidden_);
|
|
got_placeholder_hidden_.yes();
|
|
|
|
// The plugin placeholder has been hidden. End the test.
|
|
EndTest();
|
|
} else if (request == "plugin_ready") {
|
|
EXPECT_FALSE(got_plugin_ready_);
|
|
got_plugin_ready_.yes();
|
|
|
|
// The plugin has loaded the PDF file.
|
|
if (got_context_menu_dismissed_) {
|
|
// After context menu display. End the test.
|
|
EndTest();
|
|
} else {
|
|
// Trigger the context menu.
|
|
CefPostTask(TID_UI, base::Bind(&PluginTestHandler::TriggerContextMenu,
|
|
this, browser));
|
|
}
|
|
} else {
|
|
NOTREACHED();
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
void TriggerContextMenu(CefRefPtr<CefBrowser> browser) {
|
|
CefMouseEvent mouse_event;
|
|
|
|
// Somewhere in the first plugin.
|
|
mouse_event.x = 100;
|
|
mouse_event.y = 100;
|
|
|
|
// Send right-click mouse down and mouse up to tigger context menu.
|
|
browser->GetHost()->SendMouseClickEvent(mouse_event, MBT_RIGHT, false, 0);
|
|
browser->GetHost()->SendMouseClickEvent(mouse_event, MBT_RIGHT, true, 0);
|
|
}
|
|
|
|
bool RunContextMenu(CefRefPtr<CefBrowser> browser,
|
|
CefRefPtr<CefFrame> frame,
|
|
CefRefPtr<CefContextMenuParams> params,
|
|
CefRefPtr<CefMenuModel> model,
|
|
CefRefPtr<CefRunContextMenuCallback> callback) override {
|
|
EXPECT_FALSE(got_run_context_menu_);
|
|
got_run_context_menu_.yes();
|
|
|
|
if (HasContextLoad() || HasContextHide()) {
|
|
// Should have 4 elements -- plugin name, separator, run, hide.
|
|
EXPECT_EQ(4, model->GetCount());
|
|
|
|
int command_id;
|
|
if (HasContextLoad()) {
|
|
// Execute the run command.
|
|
command_id = model->GetCommandIdAt(2);
|
|
} else {
|
|
// Wait for the plugin to be hidden.
|
|
WaitForPlaceholderHide(frame);
|
|
|
|
// Execute the hide command.
|
|
command_id = model->GetCommandIdAt(3);
|
|
}
|
|
|
|
EXPECT_GE(command_id, MENU_ID_CUSTOM_FIRST);
|
|
EXPECT_LE(command_id, MENU_ID_CUSTOM_LAST);
|
|
|
|
callback->Continue(command_id, static_cast<EventFlags>(0));
|
|
} else {
|
|
// Do nothing with the context menu.
|
|
callback->Cancel();
|
|
}
|
|
return true;
|
|
}
|
|
|
|
void OnContextMenuDismissed(CefRefPtr<CefBrowser> browser,
|
|
CefRefPtr<CefFrame> frame) override {
|
|
EXPECT_FALSE(got_context_menu_dismissed_);
|
|
got_context_menu_dismissed_.yes();
|
|
|
|
if (HasContextHide()) {
|
|
// Nothing to do here. The test will continue from OnQuery.
|
|
return;
|
|
}
|
|
|
|
if (HasContextLoad()) {
|
|
// Wait for the PDF plugin to load.
|
|
WaitForPluginLoad(frame);
|
|
return;
|
|
}
|
|
|
|
EndTest();
|
|
}
|
|
|
|
void DestroyTest() override {
|
|
if (context_handler_.get()) {
|
|
context_handler_->Detach();
|
|
context_handler_ = NULL;
|
|
}
|
|
|
|
if (HasContextHide()) {
|
|
EXPECT_TRUE(got_placeholder_hidden_);
|
|
EXPECT_FALSE(got_plugin_ready_);
|
|
} else {
|
|
EXPECT_FALSE(got_placeholder_hidden_);
|
|
|
|
if (url_ == kPdfDirectUrl)
|
|
EXPECT_TRUE(got_plugin_ready_);
|
|
else
|
|
EXPECT_FALSE(got_plugin_ready_);
|
|
}
|
|
|
|
if (HasRequestContextHandler())
|
|
EXPECT_TRUE(got_on_before_plugin_empty_origin_);
|
|
else
|
|
EXPECT_FALSE(got_on_before_plugin_empty_origin_);
|
|
|
|
if (HasNoList()) {
|
|
EXPECT_TRUE(got_on_before_plugin_empty_origin2_);
|
|
EXPECT_FALSE(got_pdf_plugin_found_);
|
|
EXPECT_TRUE(got_pdf_plugin_missing_);
|
|
EXPECT_FALSE(got_run_context_menu_);
|
|
EXPECT_FALSE(got_context_menu_dismissed_);
|
|
} else {
|
|
EXPECT_FALSE(got_on_before_plugin_empty_origin2_);
|
|
EXPECT_TRUE(got_pdf_plugin_found_);
|
|
EXPECT_FALSE(got_pdf_plugin_missing_);
|
|
EXPECT_TRUE(got_run_context_menu_);
|
|
EXPECT_TRUE(got_context_menu_dismissed_);
|
|
}
|
|
|
|
if (url_ == kPdfHtmlUrl) {
|
|
// The HTML file will load the PDF twice in iframes.
|
|
EXPECT_TRUE(got_on_load_end_html_);
|
|
|
|
if (!HasNoList()) {
|
|
EXPECT_TRUE(got_on_load_end_pdf1_);
|
|
EXPECT_TRUE(got_on_load_end_pdf2_);
|
|
|
|
if (HasRequestContextHandler()) {
|
|
EXPECT_TRUE(got_on_before_plugin_load_pdf_);
|
|
}
|
|
}
|
|
} else if (url_ == kPdfDirectUrl) {
|
|
// Load the PDF file directly.
|
|
EXPECT_FALSE(got_on_load_end_html_);
|
|
EXPECT_TRUE(got_on_load_end_pdf1_);
|
|
EXPECT_FALSE(got_on_load_end_pdf2_);
|
|
|
|
if (HasRequestContextHandler()) {
|
|
EXPECT_TRUE(got_on_before_plugin_load_pdf_);
|
|
}
|
|
} else {
|
|
NOTREACHED();
|
|
}
|
|
|
|
if (!HasRequestContextHandler() || HasNoList()) {
|
|
EXPECT_FALSE(got_on_before_plugin_load_pdf_);
|
|
}
|
|
|
|
TestHandler::DestroyTest();
|
|
}
|
|
|
|
const Mode mode_;
|
|
const std::string url_;
|
|
|
|
TrackCallback got_on_before_plugin_empty_origin_;
|
|
TrackCallback got_on_before_plugin_empty_origin2_;
|
|
TrackCallback got_on_before_plugin_load_pdf_;
|
|
TrackCallback got_on_load_end_html_;
|
|
TrackCallback got_on_load_end_pdf1_;
|
|
TrackCallback got_on_load_end_pdf2_;
|
|
TrackCallback got_pdf_plugin_found_;
|
|
TrackCallback got_pdf_plugin_missing_;
|
|
TrackCallback got_placeholder_hidden_;
|
|
TrackCallback got_plugin_ready_;
|
|
TrackCallback got_run_context_menu_;
|
|
TrackCallback got_context_menu_dismissed_;
|
|
|
|
CefRefPtr<RequestContextHandler> context_handler_;
|
|
|
|
IMPLEMENT_REFCOUNTING(PluginTestHandler);
|
|
};
|
|
|
|
} // namespace
|
|
|
|
#define RUN_TEST(name, type, url) \
|
|
TEST(PluginTest, name) { \
|
|
CefRefPtr<PluginTestHandler> handler = \
|
|
new PluginTestHandler(PluginTestHandler::type, url); \
|
|
handler->ExecuteTest(); \
|
|
ReleaseAndWaitForDestructor(handler); \
|
|
}
|
|
|
|
RUN_TEST(GlobalDefaultPdfDirect, GLOBAL_DEFAULT, kPdfDirectUrl);
|
|
RUN_TEST(GlobalDefaultPdfHtml, GLOBAL_DEFAULT, kPdfHtmlUrl);
|
|
|
|
RUN_TEST(GlobalNoHandlerPdfDirect, GLOBAL_NO_HANDLER, kPdfDirectUrl);
|
|
RUN_TEST(GlobalNoHandlerPdfHtml, GLOBAL_NO_HANDLER, kPdfHtmlUrl);
|
|
RUN_TEST(GlobalAllowPdfDirect, GLOBAL_ALLOW, kPdfDirectUrl);
|
|
RUN_TEST(GlobalAllowPdfHtml, GLOBAL_ALLOW, kPdfHtmlUrl);
|
|
RUN_TEST(GlobalBlockThenLoadPdfDirect, GLOBAL_BLOCK_LOAD, kPdfDirectUrl);
|
|
RUN_TEST(GlobalBlockThenLoadPdfHtml, GLOBAL_BLOCK_LOAD, kPdfHtmlUrl);
|
|
RUN_TEST(GlobalBlockThenHidePdfDirect, GLOBAL_BLOCK_HIDE, kPdfDirectUrl);
|
|
RUN_TEST(GlobalBlockThenHidePdfHtml, GLOBAL_BLOCK_HIDE, kPdfHtmlUrl);
|
|
RUN_TEST(GlobalDisableThenHidePdfDirect, GLOBAL_DISABLE_HIDE, kPdfDirectUrl);
|
|
RUN_TEST(GlobalDisableThenHidePdfHtml, GLOBAL_DISABLE_HIDE, kPdfHtmlUrl);
|
|
RUN_TEST(GlobalNoListHtml, GLOBAL_NO_LIST, kPdfHtmlUrl);
|
|
|
|
RUN_TEST(CustomNoHandlerPdfDirect, CUSTOM_NO_HANDLER, kPdfDirectUrl);
|
|
RUN_TEST(CustomNoHandlerPdfHtml, CUSTOM_NO_HANDLER, kPdfHtmlUrl);
|
|
RUN_TEST(CustomAllowPdfDirect, CUSTOM_ALLOW, kPdfDirectUrl);
|
|
RUN_TEST(CustomAllowPdfHtml, CUSTOM_ALLOW, kPdfHtmlUrl);
|
|
RUN_TEST(CustomBlockThenLoadPdfDirect, CUSTOM_BLOCK_LOAD, kPdfDirectUrl);
|
|
RUN_TEST(CustomBlockThenLoadPdfHtml, CUSTOM_BLOCK_LOAD, kPdfHtmlUrl);
|
|
RUN_TEST(CustomBlockThenHidePdfDirect, CUSTOM_BLOCK_HIDE, kPdfDirectUrl);
|
|
RUN_TEST(CustomBlockThenHidePdfHtml, CUSTOM_BLOCK_HIDE, kPdfHtmlUrl);
|
|
RUN_TEST(CustomDisableThenHidePdfDirect, CUSTOM_DISABLE_HIDE, kPdfDirectUrl);
|
|
RUN_TEST(CustomDisableThenHidePdfHtml, CUSTOM_DISABLE_HIDE, kPdfHtmlUrl);
|
|
RUN_TEST(CustomNoListHtml, CUSTOM_NO_LIST, kPdfHtmlUrl);
|
|
|
|
// Entry point for creating plugin browser test objects.
|
|
// Called from client_app_delegates.cc.
|
|
void CreatePluginBrowserTests(
|
|
client::ClientAppBrowser::DelegateSet& delegates) {
|
|
delegates.insert(new PluginBrowserTest);
|
|
}
|