1// Copyright (c) 2012 The Chromium Authors. All rights reserved. 2// Use of this source code is governed by a BSD-style license that can be 3// found in the LICENSE file. 4 5#include "chrome/test/ppapi/ppapi_test.h" 6 7#include "base/command_line.h" 8#include "base/files/file_util.h" 9#include "base/path_service.h" 10#include "base/strings/string_util.h" 11#include "base/strings/stringprintf.h" 12#include "chrome/browser/chrome_notification_types.h" 13#include "chrome/browser/content_settings/host_content_settings_map.h" 14#include "chrome/browser/infobars/infobar_service.h" 15#include "chrome/browser/profiles/profile.h" 16#include "chrome/browser/ui/browser.h" 17#include "chrome/browser/ui/tabs/tab_strip_model.h" 18#include "chrome/common/chrome_paths.h" 19#include "chrome/common/chrome_switches.h" 20#include "chrome/test/base/test_switches.h" 21#include "chrome/test/base/ui_test_utils.h" 22#include "components/infobars/core/confirm_infobar_delegate.h" 23#include "components/infobars/core/infobar.h" 24#include "components/nacl/common/nacl_switches.h" 25#include "content/public/browser/dom_operation_notification_details.h" 26#include "content/public/browser/notification_service.h" 27#include "content/public/browser/web_contents.h" 28#include "content/public/common/content_switches.h" 29#include "media/base/media_switches.h" 30#include "net/base/filename_util.h" 31#include "net/base/test_data_directory.h" 32#include "ppapi/shared_impl/ppapi_switches.h" 33#include "ppapi/shared_impl/test_harness_utils.h" 34#include "ui/gl/gl_switches.h" 35 36using content::DomOperationNotificationDetails; 37using content::RenderViewHost; 38using content::TestMessageHandler; 39 40namespace { 41 42void AddPrivateSwitches(base::CommandLine* command_line) { 43 // For TestRequestOSFileHandle. 44 command_line->AppendSwitch(switches::kUnlimitedStorage); 45 command_line->AppendSwitchASCII(switches::kAllowNaClFileHandleAPI, 46 "127.0.0.1"); 47} 48 49} // namespace 50 51PPAPITestMessageHandler::PPAPITestMessageHandler() { 52} 53 54TestMessageHandler::MessageResponse PPAPITestMessageHandler::HandleMessage( 55 const std::string& json) { 56 std::string trimmed; 57 base::TrimString(json, "\"", &trimmed); 58 if (trimmed == "...") 59 return CONTINUE; 60 message_ = trimmed; 61 return DONE; 62} 63 64void PPAPITestMessageHandler::Reset() { 65 TestMessageHandler::Reset(); 66 message_.clear(); 67} 68 69PPAPITestBase::InfoBarObserver::InfoBarObserver(PPAPITestBase* test_base) 70 : test_base_(test_base), 71 expecting_infobar_(false), 72 should_accept_(false) { 73 registrar_.Add(this, chrome::NOTIFICATION_TAB_CONTENTS_INFOBAR_ADDED, 74 content::NotificationService::AllSources()); 75} 76 77PPAPITestBase::InfoBarObserver::~InfoBarObserver() { 78 EXPECT_FALSE(expecting_infobar_) << "Missing an expected infobar"; 79} 80 81void PPAPITestBase::InfoBarObserver::ExpectInfoBarAndAccept( 82 bool should_accept) { 83 ASSERT_FALSE(expecting_infobar_); 84 expecting_infobar_ = true; 85 should_accept_ = should_accept; 86} 87 88void PPAPITestBase::InfoBarObserver::Observe( 89 int type, 90 const content::NotificationSource& source, 91 const content::NotificationDetails& details) { 92 ASSERT_EQ(chrome::NOTIFICATION_TAB_CONTENTS_INFOBAR_ADDED, type); 93 // It's not safe to remove the infobar here, since other observers (e.g. the 94 // InfoBarContainer) may still need to access it. Instead, post a task to 95 // do all necessary infobar manipulation as soon as this call stack returns. 96 base::MessageLoop::current()->PostTask( 97 FROM_HERE, base::Bind(&InfoBarObserver::VerifyInfoBarState, 98 base::Unretained(this))); 99} 100 101void PPAPITestBase::InfoBarObserver::VerifyInfoBarState() { 102 content::WebContents* web_contents = 103 test_base_->browser()->tab_strip_model()->GetActiveWebContents(); 104 ASSERT_TRUE(web_contents != NULL); 105 InfoBarService* infobar_service = 106 InfoBarService::FromWebContents(web_contents); 107 ASSERT_TRUE(infobar_service != NULL); 108 109 EXPECT_EQ(expecting_infobar_ ? 1U : 0U, infobar_service->infobar_count()); 110 if (!expecting_infobar_) 111 return; 112 expecting_infobar_ = false; 113 114 infobars::InfoBar* infobar = infobar_service->infobar_at(0); 115 ConfirmInfoBarDelegate* delegate = 116 infobar->delegate()->AsConfirmInfoBarDelegate(); 117 ASSERT_TRUE(delegate != NULL); 118 if (should_accept_) 119 delegate->Accept(); 120 else 121 delegate->Cancel(); 122 123 infobar_service->RemoveInfoBar(infobar); 124} 125 126PPAPITestBase::PPAPITestBase() { 127} 128 129void PPAPITestBase::SetUp() { 130 EnablePixelOutput(); 131 InProcessBrowserTest::SetUp(); 132} 133 134void PPAPITestBase::SetUpCommandLine(base::CommandLine* command_line) { 135 // The test sends us the result via a cookie. 136 command_line->AppendSwitch(switches::kEnableFileCookies); 137 138 // Some stuff is hung off of the testing interface which is not enabled 139 // by default. 140 command_line->AppendSwitch(switches::kEnablePepperTesting); 141 142 // Smooth scrolling confuses the scrollbar test. 143 command_line->AppendSwitch(switches::kDisableSmoothScrolling); 144} 145 146void PPAPITestBase::SetUpOnMainThread() { 147 // Always allow access to the PPAPI broker. 148 browser()->profile()->GetHostContentSettingsMap()->SetDefaultContentSetting( 149 CONTENT_SETTINGS_TYPE_PPAPI_BROKER, CONTENT_SETTING_ALLOW); 150} 151 152GURL PPAPITestBase::GetTestFileUrl(const std::string& test_case) { 153 base::FilePath test_path; 154 EXPECT_TRUE(PathService::Get(base::DIR_SOURCE_ROOT, &test_path)); 155 test_path = test_path.Append(FILE_PATH_LITERAL("ppapi")); 156 test_path = test_path.Append(FILE_PATH_LITERAL("tests")); 157 test_path = test_path.Append(FILE_PATH_LITERAL("test_case.html")); 158 159 // Sanity check the file name. 160 EXPECT_TRUE(base::PathExists(test_path)); 161 162 GURL test_url = net::FilePathToFileURL(test_path); 163 164 GURL::Replacements replacements; 165 std::string query = BuildQuery(std::string(), test_case); 166 replacements.SetQuery(query.c_str(), url::Component(0, query.size())); 167 return test_url.ReplaceComponents(replacements); 168} 169 170void PPAPITestBase::RunTest(const std::string& test_case) { 171 GURL url = GetTestFileUrl(test_case); 172 RunTestURL(url); 173} 174 175void PPAPITestBase::RunTestViaHTTP(const std::string& test_case) { 176 base::FilePath document_root; 177 ASSERT_TRUE(ui_test_utils::GetRelativeBuildDirectory(&document_root)); 178 base::FilePath http_document_root; 179 ASSERT_TRUE(ui_test_utils::GetRelativeBuildDirectory(&http_document_root)); 180 net::SpawnedTestServer http_server(net::SpawnedTestServer::TYPE_HTTP, 181 net::SpawnedTestServer::kLocalhost, 182 document_root); 183 ASSERT_TRUE(http_server.Start()); 184 RunTestURL(GetTestURL(http_server, test_case, std::string())); 185} 186 187void PPAPITestBase::RunTestWithSSLServer(const std::string& test_case) { 188 base::FilePath http_document_root; 189 ASSERT_TRUE(ui_test_utils::GetRelativeBuildDirectory(&http_document_root)); 190 net::SpawnedTestServer http_server(net::SpawnedTestServer::TYPE_HTTP, 191 net::SpawnedTestServer::kLocalhost, 192 http_document_root); 193 net::SpawnedTestServer ssl_server(net::SpawnedTestServer::TYPE_HTTPS, 194 net::BaseTestServer::SSLOptions(), 195 http_document_root); 196 // Start the servers in parallel. 197 ASSERT_TRUE(http_server.StartInBackground()); 198 ASSERT_TRUE(ssl_server.StartInBackground()); 199 // Wait until they are both finished before continuing. 200 ASSERT_TRUE(http_server.BlockUntilStarted()); 201 ASSERT_TRUE(ssl_server.BlockUntilStarted()); 202 203 uint16_t port = ssl_server.host_port_pair().port(); 204 RunTestURL(GetTestURL(http_server, 205 test_case, 206 base::StringPrintf("ssl_server_port=%d", port))); 207} 208 209void PPAPITestBase::RunTestWithWebSocketServer(const std::string& test_case) { 210 base::FilePath http_document_root; 211 ASSERT_TRUE(ui_test_utils::GetRelativeBuildDirectory(&http_document_root)); 212 net::SpawnedTestServer http_server(net::SpawnedTestServer::TYPE_HTTP, 213 net::SpawnedTestServer::kLocalhost, 214 http_document_root); 215 net::SpawnedTestServer ws_server(net::SpawnedTestServer::TYPE_WS, 216 net::SpawnedTestServer::kLocalhost, 217 net::GetWebSocketTestDataDirectory()); 218 // Start the servers in parallel. 219 ASSERT_TRUE(http_server.StartInBackground()); 220 ASSERT_TRUE(ws_server.StartInBackground()); 221 // Wait until they are both finished before continuing. 222 ASSERT_TRUE(http_server.BlockUntilStarted()); 223 ASSERT_TRUE(ws_server.BlockUntilStarted()); 224 225 std::string host = ws_server.host_port_pair().HostForURL(); 226 uint16_t port = ws_server.host_port_pair().port(); 227 RunTestURL(GetTestURL(http_server, 228 test_case, 229 base::StringPrintf( 230 "websocket_host=%s&websocket_port=%d", 231 host.c_str(), 232 port))); 233} 234 235void PPAPITestBase::RunTestIfAudioOutputAvailable( 236 const std::string& test_case) { 237 RunTest(test_case); 238} 239 240void PPAPITestBase::RunTestViaHTTPIfAudioOutputAvailable( 241 const std::string& test_case) { 242 RunTestViaHTTP(test_case); 243} 244 245void PPAPITestBase::RunTestURL(const GURL& test_url) { 246#if defined(OS_WIN) && defined(USE_ASH) 247 // PPAPITests are broken in Ash browser tests (http://crbug.com/263548). 248 if (base::CommandLine::ForCurrentProcess()->HasSwitch( 249 switches::kAshBrowserTests)) { 250 LOG(WARNING) << "PPAPITests are disabled for Ash browser tests."; 251 return; 252 } 253#endif 254 255 // See comment above TestingInstance in ppapi/test/testing_instance.h. 256 // Basically it sends messages using the DOM automation controller. The 257 // value of "..." means it's still working and we should continue to wait, 258 // any other value indicates completion (in this case it will start with 259 // "PASS" or "FAIL"). This keeps us from timing out on waits for long tests. 260 PPAPITestMessageHandler handler; 261 content::JavascriptTestObserver observer( 262 browser()->tab_strip_model()->GetActiveWebContents(), 263 &handler); 264 265 ui_test_utils::NavigateToURL(browser(), test_url); 266 267 ASSERT_TRUE(observer.Run()) << handler.error_message(); 268 EXPECT_STREQ("PASS", handler.message().c_str()); 269} 270 271GURL PPAPITestBase::GetTestURL( 272 const net::SpawnedTestServer& http_server, 273 const std::string& test_case, 274 const std::string& extra_params) { 275 std::string query = BuildQuery("files/test_case.html?", test_case); 276 if (!extra_params.empty()) 277 query = base::StringPrintf("%s&%s", query.c_str(), extra_params.c_str()); 278 279 return http_server.GetURL(query); 280} 281 282PPAPITest::PPAPITest() : in_process_(true) { 283} 284 285void PPAPITest::SetUpCommandLine(base::CommandLine* command_line) { 286 PPAPITestBase::SetUpCommandLine(command_line); 287 288 base::FilePath plugin_dir; 289 EXPECT_TRUE(PathService::Get(base::DIR_MODULE, &plugin_dir)); 290 291 base::FilePath plugin_lib = plugin_dir.Append(ppapi::GetTestLibraryName()); 292 EXPECT_TRUE(base::PathExists(plugin_lib)); 293 294 // Append the switch to register the pepper plugin. 295 // library path = <out dir>/<test_name>.<library_extension> 296 // library name = "PPAPI Tests" 297 // version = "1.2.3" 298 // MIME type = application/x-ppapi-<test_name> 299 base::FilePath::StringType pepper_plugin = plugin_lib.value(); 300 pepper_plugin.append(FILE_PATH_LITERAL("#PPAPI Tests")); 301 pepper_plugin.append(FILE_PATH_LITERAL("#")); // No description. 302 pepper_plugin.append(FILE_PATH_LITERAL("#1.2.3")); 303 pepper_plugin.append(FILE_PATH_LITERAL(";application/x-ppapi-tests")); 304 command_line->AppendSwitchNative(switches::kRegisterPepperPlugins, 305 pepper_plugin); 306 307 command_line->AppendSwitchASCII(switches::kAllowNaClSocketAPI, "127.0.0.1"); 308 if (in_process_) 309 command_line->AppendSwitch(switches::kPpapiInProcess); 310} 311 312std::string PPAPITest::BuildQuery(const std::string& base, 313 const std::string& test_case){ 314 return base::StringPrintf("%stestcase=%s", base.c_str(), test_case.c_str()); 315} 316 317void PPAPIPrivateTest::SetUpCommandLine(base::CommandLine* command_line) { 318 PPAPITest::SetUpCommandLine(command_line); 319 AddPrivateSwitches(command_line); 320} 321 322OutOfProcessPPAPITest::OutOfProcessPPAPITest() { 323 in_process_ = false; 324} 325 326void OutOfProcessPPAPITest::SetUpCommandLine(base::CommandLine* command_line) { 327 PPAPITest::SetUpCommandLine(command_line); 328 command_line->AppendSwitch(switches::kUseFakeDeviceForMediaStream); 329 command_line->AppendSwitch(switches::kUseFakeUIForMediaStream); 330} 331 332void OutOfProcessPPAPIPrivateTest::SetUpCommandLine( 333 base::CommandLine* command_line) { 334 OutOfProcessPPAPITest::SetUpCommandLine(command_line); 335 AddPrivateSwitches(command_line); 336} 337 338void PPAPINaClTest::SetUpCommandLine(base::CommandLine* command_line) { 339#if !defined(DISABLE_NACL) 340 PPAPITestBase::SetUpCommandLine(command_line); 341 342 // Enable running (non-portable) NaCl outside of the Chrome web store. 343 command_line->AppendSwitch(switches::kEnableNaCl); 344 command_line->AppendSwitchASCII(switches::kAllowNaClSocketAPI, "127.0.0.1"); 345 command_line->AppendSwitch(switches::kUseFakeDeviceForMediaStream); 346 command_line->AppendSwitch(switches::kUseFakeUIForMediaStream); 347#endif 348} 349 350void PPAPINaClTest::SetUpOnMainThread() { 351} 352 353void PPAPINaClTest::RunTest(const std::string& test_case) { 354#if !defined(DISABLE_NACL) 355 PPAPITestBase::RunTest(test_case); 356#endif 357} 358 359void PPAPINaClTest::RunTestViaHTTP(const std::string& test_case) { 360#if !defined(DISABLE_NACL) 361 PPAPITestBase::RunTestViaHTTP(test_case); 362#endif 363} 364 365void PPAPINaClTest::RunTestWithSSLServer(const std::string& test_case) { 366#if !defined(DISABLE_NACL) 367 PPAPITestBase::RunTestWithSSLServer(test_case); 368#endif 369} 370 371void PPAPINaClTest::RunTestWithWebSocketServer(const std::string& test_case) { 372#if !defined(DISABLE_NACL) 373 PPAPITestBase::RunTestWithWebSocketServer(test_case); 374#endif 375} 376 377void PPAPINaClTest::RunTestIfAudioOutputAvailable( 378 const std::string& test_case) { 379#if !defined(DISABLE_NACL) 380 PPAPITestBase::RunTestIfAudioOutputAvailable(test_case); 381#endif 382} 383 384void PPAPINaClTest::RunTestViaHTTPIfAudioOutputAvailable( 385 const std::string& test_case) { 386#if !defined(DISABLE_NACL) 387 PPAPITestBase::RunTestViaHTTPIfAudioOutputAvailable(test_case); 388#endif 389} 390 391// Append the correct mode and testcase string 392std::string PPAPINaClNewlibTest::BuildQuery(const std::string& base, 393 const std::string& test_case) { 394 return base::StringPrintf("%smode=nacl_newlib&testcase=%s", base.c_str(), 395 test_case.c_str()); 396} 397 398void PPAPIPrivateNaClNewlibTest::SetUpCommandLine( 399 base::CommandLine* command_line) { 400 PPAPINaClNewlibTest::SetUpCommandLine(command_line); 401 AddPrivateSwitches(command_line); 402} 403 404// Append the correct mode and testcase string 405std::string PPAPINaClGLibcTest::BuildQuery(const std::string& base, 406 const std::string& test_case) { 407 return base::StringPrintf("%smode=nacl_glibc&testcase=%s", base.c_str(), 408 test_case.c_str()); 409} 410 411void PPAPIPrivateNaClGLibcTest::SetUpCommandLine( 412 base::CommandLine* command_line) { 413 PPAPINaClGLibcTest::SetUpCommandLine(command_line); 414 AddPrivateSwitches(command_line); 415} 416 417// Append the correct mode and testcase string 418std::string PPAPINaClPNaClTest::BuildQuery(const std::string& base, 419 const std::string& test_case) { 420 return base::StringPrintf("%smode=nacl_pnacl&testcase=%s", base.c_str(), 421 test_case.c_str()); 422} 423 424void PPAPIPrivateNaClPNaClTest::SetUpCommandLine( 425 base::CommandLine* command_line) { 426 PPAPINaClPNaClTest::SetUpCommandLine(command_line); 427 AddPrivateSwitches(command_line); 428} 429 430void PPAPINaClPNaClNonSfiTest::SetUpCommandLine( 431 base::CommandLine* command_line) { 432#if !defined(DISABLE_NACL) 433 PPAPINaClTest::SetUpCommandLine(command_line); 434 command_line->AppendSwitch(switches::kEnableNaClNonSfiMode); 435#endif 436} 437 438std::string PPAPINaClPNaClNonSfiTest::BuildQuery( 439 const std::string& base, 440 const std::string& test_case) { 441 return base::StringPrintf("%smode=nacl_pnacl_nonsfi&testcase=%s", 442 base.c_str(), test_case.c_str()); 443} 444 445void PPAPIPrivateNaClPNaClNonSfiTest::SetUpCommandLine( 446 base::CommandLine* command_line) { 447 PPAPINaClPNaClNonSfiTest::SetUpCommandLine(command_line); 448 AddPrivateSwitches(command_line); 449} 450 451void PPAPINaClTestDisallowedSockets::SetUpCommandLine( 452 base::CommandLine* command_line) { 453 PPAPITestBase::SetUpCommandLine(command_line); 454 455 // Enable running (non-portable) NaCl outside of the Chrome web store. 456 command_line->AppendSwitch(switches::kEnableNaCl); 457} 458 459// Append the correct mode and testcase string 460std::string PPAPINaClTestDisallowedSockets::BuildQuery( 461 const std::string& base, 462 const std::string& test_case) { 463 return base::StringPrintf("%smode=nacl_newlib&testcase=%s", base.c_str(), 464 test_case.c_str()); 465} 466 467void PPAPIBrokerInfoBarTest::SetUpOnMainThread() { 468 // The default content setting for the PPAPI broker is ASK. We purposefully 469 // don't call PPAPITestBase::SetUpOnMainThread() to keep it that way. 470} 471