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 <list> 6 #include <set> 7 8 #include "base/memory/ref_counted.h" 9 #include "base/memory/weak_ptr.h" 10 #include "base/strings/stringprintf.h" 11 #include "base/strings/utf_string_conversions.h" 12 #include "chrome/app/chrome_command_ids.h" 13 #include "chrome/browser/browser_process.h" 14 #include "chrome/browser/chrome_browser_main.h" 15 #include "chrome/browser/chrome_browser_main_extra_parts.h" 16 #include "chrome/browser/chrome_content_browser_client.h" 17 #include "chrome/browser/chrome_notification_types.h" 18 #include "chrome/browser/extensions/api/web_navigation/web_navigation_api.h" 19 #include "chrome/browser/extensions/extension_apitest.h" 20 #include "chrome/browser/extensions/extension_service.h" 21 #include "chrome/browser/extensions/extension_system.h" 22 #include "chrome/browser/profiles/profile.h" 23 #include "chrome/browser/renderer_host/chrome_resource_dispatcher_host_delegate.h" 24 #include "chrome/browser/tab_contents/render_view_context_menu.h" 25 #include "chrome/browser/ui/browser.h" 26 #include "chrome/browser/ui/tabs/tab_strip_model.h" 27 #include "chrome/test/base/ui_test_utils.h" 28 #include "content/public/browser/browser_thread.h" 29 #include "content/public/browser/render_process_host.h" 30 #include "content/public/browser/render_view_host.h" 31 #include "content/public/browser/resource_controller.h" 32 #include "content/public/browser/resource_dispatcher_host.h" 33 #include "content/public/browser/resource_throttle.h" 34 #include "content/public/browser/web_contents.h" 35 #include "content/public/common/context_menu_params.h" 36 #include "content/public/common/url_constants.h" 37 #include "content/public/test/browser_test_utils.h" 38 #include "extensions/common/switches.h" 39 #include "net/dns/mock_host_resolver.h" 40 #include "net/test/embedded_test_server/embedded_test_server.h" 41 #include "third_party/WebKit/public/web/WebContextMenuData.h" 42 #include "third_party/WebKit/public/web/WebInputEvent.h" 43 #include "webkit/common/resource_type.h" 44 45 using content::WebContents; 46 47 namespace extensions { 48 49 namespace { 50 51 // An UI-less RenderViewContextMenu. 52 class TestRenderViewContextMenu : public RenderViewContextMenu { 53 public: 54 TestRenderViewContextMenu(WebContents* web_contents, 55 const content::ContextMenuParams& params) 56 : RenderViewContextMenu(web_contents, params) { 57 } 58 virtual ~TestRenderViewContextMenu() {} 59 60 private: 61 virtual void PlatformInit() OVERRIDE {} 62 virtual void PlatformCancel() OVERRIDE {} 63 virtual bool GetAcceleratorForCommandId(int, ui::Accelerator*) OVERRIDE { 64 return false; 65 } 66 67 DISALLOW_COPY_AND_ASSIGN(TestRenderViewContextMenu); 68 }; 69 70 71 // This class can defer requests for arbitrary URLs. 72 class TestNavigationListener 73 : public base::RefCountedThreadSafe<TestNavigationListener> { 74 public: 75 TestNavigationListener() {} 76 77 // Add |url| to the set of URLs we should delay. 78 void DelayRequestsForURL(const GURL& url) { 79 if (!content::BrowserThread::CurrentlyOn(content::BrowserThread::IO)) { 80 content::BrowserThread::PostTask( 81 content::BrowserThread::IO, 82 FROM_HERE, 83 base::Bind(&TestNavigationListener::DelayRequestsForURL, this, url)); 84 return; 85 } 86 urls_to_delay_.insert(url); 87 } 88 89 // Resume all deferred requests. 90 void ResumeAll() { 91 if (!content::BrowserThread::CurrentlyOn(content::BrowserThread::IO)) { 92 content::BrowserThread::PostTask( 93 content::BrowserThread::IO, 94 FROM_HERE, 95 base::Bind(&TestNavigationListener::ResumeAll, this)); 96 return; 97 } 98 WeakThrottleList::const_iterator it; 99 for (it = throttles_.begin(); it != throttles_.end(); ++it) { 100 if (it->get()) 101 (*it)->Resume(); 102 } 103 throttles_.clear(); 104 } 105 106 // Constructs a ResourceThrottle if the request for |url| should be held. 107 // 108 // Needs to be invoked on the IO thread. 109 content::ResourceThrottle* CreateResourceThrottle( 110 const GURL& url, 111 ResourceType::Type resource_type) { 112 DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::IO)); 113 if (urls_to_delay_.find(url) == urls_to_delay_.end()) 114 return NULL; 115 116 Throttle* throttle = new Throttle(); 117 throttles_.push_back(throttle->AsWeakPtr()); 118 return throttle; 119 } 120 121 private: 122 friend class base::RefCountedThreadSafe<TestNavigationListener>; 123 124 virtual ~TestNavigationListener() {} 125 126 // Stores a throttle per URL request that we have delayed. 127 class Throttle : public content::ResourceThrottle, 128 public base::SupportsWeakPtr<Throttle> { 129 public: 130 void Resume() { 131 controller()->Resume(); 132 } 133 134 // content::ResourceThrottle implementation. 135 virtual void WillStartRequest(bool* defer) OVERRIDE { 136 *defer = true; 137 } 138 }; 139 typedef base::WeakPtr<Throttle> WeakThrottle; 140 typedef std::list<WeakThrottle> WeakThrottleList; 141 WeakThrottleList throttles_; 142 143 // The set of URLs to be delayed. 144 std::set<GURL> urls_to_delay_; 145 146 DISALLOW_COPY_AND_ASSIGN(TestNavigationListener); 147 }; 148 149 // Waits for a WC to be created. Once it starts loading |delay_url| (after at 150 // least the first navigation has committed), it delays the load, executes 151 // |script| in the last committed RVH and resumes the load when |until_url| 152 // commits. This class expects |script| to trigger the load of |until_url|. 153 class DelayLoadStartAndExecuteJavascript 154 : public content::NotificationObserver, 155 public content::WebContentsObserver { 156 public: 157 DelayLoadStartAndExecuteJavascript( 158 TestNavigationListener* test_navigation_listener, 159 const GURL& delay_url, 160 const std::string& script, 161 const GURL& until_url) 162 : content::WebContentsObserver(), 163 test_navigation_listener_(test_navigation_listener), 164 delay_url_(delay_url), 165 until_url_(until_url), 166 script_(script), 167 script_was_executed_(false), 168 rvh_(NULL) { 169 registrar_.Add(this, 170 chrome::NOTIFICATION_TAB_ADDED, 171 content::NotificationService::AllSources()); 172 test_navigation_listener_->DelayRequestsForURL(delay_url_); 173 } 174 virtual ~DelayLoadStartAndExecuteJavascript() {} 175 176 virtual void Observe(int type, 177 const content::NotificationSource& source, 178 const content::NotificationDetails& details) OVERRIDE { 179 if (type != chrome::NOTIFICATION_TAB_ADDED) { 180 NOTREACHED(); 181 return; 182 } 183 content::WebContentsObserver::Observe( 184 content::Details<content::WebContents>(details).ptr()); 185 registrar_.RemoveAll(); 186 } 187 188 virtual void DidStartProvisionalLoadForFrame( 189 int64 frame_id, 190 int64 parent_frame_id, 191 bool is_main_frame, 192 const GURL& validated_url, 193 bool is_error_page, 194 bool is_iframe_srcdoc, 195 content::RenderViewHost* render_view_host) OVERRIDE { 196 if (validated_url != delay_url_ || !rvh_) 197 return; 198 199 rvh_->ExecuteJavascriptInWebFrame(string16(), UTF8ToUTF16(script_)); 200 script_was_executed_ = true; 201 } 202 203 virtual void DidCommitProvisionalLoadForFrame( 204 int64 frame_id, 205 bool is_main_frame, 206 const GURL& url, 207 content::PageTransition transition_type, 208 content::RenderViewHost* render_view_host) OVERRIDE { 209 if (script_was_executed_ && url == until_url_) { 210 content::WebContentsObserver::Observe(NULL); 211 test_navigation_listener_->ResumeAll(); 212 } 213 rvh_ = render_view_host; 214 } 215 216 private: 217 content::NotificationRegistrar registrar_; 218 219 scoped_refptr<TestNavigationListener> test_navigation_listener_; 220 221 GURL delay_url_; 222 GURL until_url_; 223 std::string script_; 224 bool script_was_executed_; 225 content::RenderViewHost* rvh_; 226 227 DISALLOW_COPY_AND_ASSIGN(DelayLoadStartAndExecuteJavascript); 228 }; 229 230 // A ResourceDispatcherHostDelegate that adds a TestNavigationObserver. 231 class TestResourceDispatcherHostDelegate 232 : public ChromeResourceDispatcherHostDelegate { 233 public: 234 TestResourceDispatcherHostDelegate( 235 prerender::PrerenderTracker* prerender_tracker, 236 TestNavigationListener* test_navigation_listener) 237 : ChromeResourceDispatcherHostDelegate(prerender_tracker), 238 test_navigation_listener_(test_navigation_listener) { 239 } 240 virtual ~TestResourceDispatcherHostDelegate() {} 241 242 virtual void RequestBeginning( 243 net::URLRequest* request, 244 content::ResourceContext* resource_context, 245 appcache::AppCacheService* appcache_service, 246 ResourceType::Type resource_type, 247 int child_id, 248 int route_id, 249 bool is_continuation_of_transferred_request, 250 ScopedVector<content::ResourceThrottle>* throttles) OVERRIDE { 251 ChromeResourceDispatcherHostDelegate::RequestBeginning( 252 request, 253 resource_context, 254 appcache_service, 255 resource_type, 256 child_id, 257 route_id, 258 is_continuation_of_transferred_request, 259 throttles); 260 content::ResourceThrottle* throttle = 261 test_navigation_listener_->CreateResourceThrottle(request->url(), 262 resource_type); 263 if (throttle) 264 throttles->push_back(throttle); 265 } 266 267 private: 268 scoped_refptr<TestNavigationListener> test_navigation_listener_; 269 270 DISALLOW_COPY_AND_ASSIGN(TestResourceDispatcherHostDelegate); 271 }; 272 273 // Used to manage the lifetime of the TestResourceDispatcherHostDelegate which 274 // needs to be deleted before the threads are stopped. 275 class TestBrowserMainExtraParts : public ChromeBrowserMainExtraParts { 276 public: 277 explicit TestBrowserMainExtraParts( 278 TestNavigationListener* test_navigation_listener) 279 : test_navigation_listener_(test_navigation_listener) { 280 } 281 virtual ~TestBrowserMainExtraParts() {} 282 283 TestResourceDispatcherHostDelegate* resource_dispatcher_host_delegate() { 284 if (!resource_dispatcher_host_delegate_.get()) { 285 resource_dispatcher_host_delegate_.reset( 286 new TestResourceDispatcherHostDelegate( 287 g_browser_process->prerender_tracker(), 288 test_navigation_listener_.get())); 289 } 290 return resource_dispatcher_host_delegate_.get(); 291 } 292 293 // ChromeBrowserMainExtraParts implementation. 294 virtual void PostMainMessageLoopRun() OVERRIDE { 295 resource_dispatcher_host_delegate_.reset(); 296 } 297 298 private: 299 scoped_refptr<TestNavigationListener> test_navigation_listener_; 300 scoped_ptr<TestResourceDispatcherHostDelegate> 301 resource_dispatcher_host_delegate_; 302 303 DISALLOW_COPY_AND_ASSIGN(TestBrowserMainExtraParts); 304 }; 305 306 // A ContentBrowserClient that doesn't forward the RDH created signal. 307 class TestContentBrowserClient : public chrome::ChromeContentBrowserClient { 308 public: 309 explicit TestContentBrowserClient( 310 TestNavigationListener* test_navigation_listener) 311 : test_navigation_listener_(test_navigation_listener) { 312 } 313 virtual ~TestContentBrowserClient() {} 314 315 virtual void ResourceDispatcherHostCreated() OVERRIDE { 316 // Don't invoke ChromeContentBrowserClient::ResourceDispatcherHostCreated. 317 // It would notify BrowserProcessImpl which would create a 318 // ChromeResourceDispatcherHostDelegate and other objects. Not creating 319 // other objects might turn out to be a problem in the future. 320 content::ResourceDispatcherHost::Get()->SetDelegate( 321 browser_main_extra_parts_->resource_dispatcher_host_delegate()); 322 } 323 324 virtual content::BrowserMainParts* CreateBrowserMainParts( 325 const content::MainFunctionParams& parameters) OVERRIDE { 326 ChromeBrowserMainParts* main_parts = static_cast<ChromeBrowserMainParts*>( 327 ChromeContentBrowserClient::CreateBrowserMainParts(parameters)); 328 329 browser_main_extra_parts_ = 330 new TestBrowserMainExtraParts(test_navigation_listener_.get()); 331 main_parts->AddParts(browser_main_extra_parts_); 332 return main_parts; 333 } 334 335 private: 336 scoped_refptr<TestNavigationListener> test_navigation_listener_; 337 TestBrowserMainExtraParts* browser_main_extra_parts_; 338 339 DISALLOW_COPY_AND_ASSIGN(TestContentBrowserClient); 340 }; 341 342 } // namespace 343 344 class WebNavigationApiTest : public ExtensionApiTest { 345 public: 346 WebNavigationApiTest() {} 347 virtual ~WebNavigationApiTest() {} 348 349 virtual void SetUpInProcessBrowserTestFixture() OVERRIDE { 350 ExtensionApiTest::SetUpInProcessBrowserTestFixture(); 351 352 test_navigation_listener_ = new TestNavigationListener(); 353 content_browser_client_.reset( 354 new TestContentBrowserClient(test_navigation_listener_.get())); 355 original_content_browser_client_ = content::SetBrowserClientForTesting( 356 content_browser_client_.get()); 357 358 FrameNavigationState::set_allow_extension_scheme(true); 359 360 CommandLine::ForCurrentProcess()->AppendSwitch( 361 switches::kAllowLegacyExtensionManifests); 362 363 host_resolver()->AddRule("*", "127.0.0.1"); 364 } 365 366 virtual void TearDownInProcessBrowserTestFixture() OVERRIDE { 367 ExtensionApiTest::TearDownInProcessBrowserTestFixture(); 368 content::SetBrowserClientForTesting(original_content_browser_client_); 369 } 370 371 TestNavigationListener* test_navigation_listener() { 372 return test_navigation_listener_.get(); 373 } 374 375 private: 376 scoped_refptr<TestNavigationListener> test_navigation_listener_; 377 scoped_ptr<TestContentBrowserClient> content_browser_client_; 378 content::ContentBrowserClient* original_content_browser_client_; 379 380 DISALLOW_COPY_AND_ASSIGN(WebNavigationApiTest); 381 }; 382 383 // Fails often on Windows dbg bots. http://crbug.com/177163 384 #if defined(OS_WIN) 385 #define MAYBE_Api DISABLED_Api 386 #else 387 #define MAYBE_Api Api 388 #endif // defined(OS_WIN) 389 IN_PROC_BROWSER_TEST_F(WebNavigationApiTest, MAYBE_Api) { 390 ASSERT_TRUE(StartEmbeddedTestServer()); 391 ASSERT_TRUE( 392 RunExtensionSubtest("webnavigation", "test_api.html")) << message_; 393 } 394 395 // Fails often on Windows dbg bots. http://crbug.com/177163 396 #if defined(OS_WIN) 397 #define MAYBE_GetFrame DISABLED_GetFrame 398 #else 399 #define MAYBE_GetFrame GetFrame 400 #endif // defined(OS_WIN) 401 IN_PROC_BROWSER_TEST_F(WebNavigationApiTest, MAYBE_GetFrame) { 402 ASSERT_TRUE(StartEmbeddedTestServer()); 403 ASSERT_TRUE( 404 RunExtensionSubtest("webnavigation", "test_getFrame.html")) << message_; 405 } 406 407 IN_PROC_BROWSER_TEST_F(WebNavigationApiTest, ClientRedirect) { 408 ASSERT_TRUE(StartEmbeddedTestServer()); 409 ASSERT_TRUE( 410 RunExtensionSubtest("webnavigation", "test_clientRedirect.html")) 411 << message_; 412 } 413 414 IN_PROC_BROWSER_TEST_F(WebNavigationApiTest, ServerRedirect) { 415 ASSERT_TRUE(StartEmbeddedTestServer()); 416 ASSERT_TRUE( 417 RunExtensionSubtest("webnavigation", "test_serverRedirect.html")) 418 << message_; 419 } 420 421 // http://crbug.com/235171 and http://crbug.com/177163 422 #if (defined(OS_WIN) && !defined(NDEBUG)) || \ 423 (defined(OS_CHROMEOS) || (defined(OS_LINUX) && defined(USE_AURA))) 424 #define MAYBE_ServerRedirectSingleProcess DISABLED_ServerRedirectSingleProcess 425 #else 426 #define MAYBE_ServerRedirectSingleProcess ServerRedirectSingleProcess 427 #endif 428 IN_PROC_BROWSER_TEST_F(WebNavigationApiTest, 429 MAYBE_ServerRedirectSingleProcess) { 430 ASSERT_TRUE(StartEmbeddedTestServer()); 431 432 // Set max renderers to 1 to force running out of processes. 433 content::RenderProcessHost::SetMaxRendererProcessCount(1); 434 435 // Wait for the extension to set itself up and return control to us. 436 ASSERT_TRUE(RunExtensionSubtest( 437 "webnavigation", "test_serverRedirectSingleProcess.html")) 438 << message_; 439 440 WebContents* tab = browser()->tab_strip_model()->GetActiveWebContents(); 441 content::WaitForLoadStop(tab); 442 443 ResultCatcher catcher; 444 GURL url(base::StringPrintf( 445 "http://www.a.com:%d/" 446 "extensions/api_test/webnavigation/serverRedirect/a.html", 447 embedded_test_server()->port())); 448 449 ui_test_utils::NavigateToURL(browser(), url); 450 451 url = GURL(base::StringPrintf( 452 "http://www.b.com:%d/server-redirect?http://www.b.com:%d/", 453 embedded_test_server()->port(), 454 embedded_test_server()->port())); 455 456 ui_test_utils::NavigateToURL(browser(), url); 457 458 ASSERT_TRUE(catcher.GetNextResult()) << catcher.message(); 459 } 460 461 IN_PROC_BROWSER_TEST_F(WebNavigationApiTest, ForwardBack) { 462 ASSERT_TRUE(StartEmbeddedTestServer()); 463 ASSERT_TRUE( 464 RunExtensionSubtest("webnavigation", "test_forwardBack.html")) 465 << message_; 466 } 467 468 IN_PROC_BROWSER_TEST_F(WebNavigationApiTest, IFrame) { 469 ASSERT_TRUE(StartEmbeddedTestServer()); 470 ASSERT_TRUE( 471 RunExtensionSubtest("webnavigation", "test_iframe.html")) << message_; 472 } 473 474 IN_PROC_BROWSER_TEST_F(WebNavigationApiTest, SrcDoc) { 475 ASSERT_TRUE(StartEmbeddedTestServer()); 476 ASSERT_TRUE( 477 RunExtensionSubtest("webnavigation", "test_srcdoc.html")) << message_; 478 } 479 480 IN_PROC_BROWSER_TEST_F(WebNavigationApiTest, OpenTab) { 481 ASSERT_TRUE(StartEmbeddedTestServer()); 482 ASSERT_TRUE( 483 RunExtensionSubtest("webnavigation", "test_openTab.html")) << message_; 484 } 485 486 IN_PROC_BROWSER_TEST_F(WebNavigationApiTest, ReferenceFragment) { 487 ASSERT_TRUE(StartEmbeddedTestServer()); 488 ASSERT_TRUE( 489 RunExtensionSubtest("webnavigation", "test_referenceFragment.html")) 490 << message_; 491 } 492 493 IN_PROC_BROWSER_TEST_F(WebNavigationApiTest, SimpleLoad) { 494 ASSERT_TRUE(StartEmbeddedTestServer()); 495 ASSERT_TRUE( 496 RunExtensionSubtest("webnavigation", "test_simpleLoad.html")) << message_; 497 } 498 499 // Fails often on Windows dbg bots. http://crbug.com/177163 500 #if defined(OS_WIN) 501 #define MAYBE_Failures DISABLED_Failures 502 #else 503 #define MAYBE_Failures Failures 504 #endif // defined(OS_WIN) 505 IN_PROC_BROWSER_TEST_F(WebNavigationApiTest, MAYBE_Failures) { 506 ASSERT_TRUE(StartEmbeddedTestServer()); 507 ASSERT_TRUE( 508 RunExtensionSubtest("webnavigation", "test_failures.html")) << message_; 509 } 510 511 IN_PROC_BROWSER_TEST_F(WebNavigationApiTest, FilteredTest) { 512 ASSERT_TRUE(StartEmbeddedTestServer()); 513 ASSERT_TRUE( 514 RunExtensionSubtest("webnavigation", "test_filtered.html")) << message_; 515 } 516 517 // Fails often on Windows dbg bots. http://crbug.com/177163 518 #if defined(OS_WIN) 519 #define MAYBE_UserAction DISABLED_UserAction 520 #else 521 #define MAYBE_UserAction UserAction 522 #endif // defined(OS_WIN) 523 IN_PROC_BROWSER_TEST_F(WebNavigationApiTest, MAYBE_UserAction) { 524 ASSERT_TRUE(StartEmbeddedTestServer()); 525 526 // Wait for the extension to set itself up and return control to us. 527 ASSERT_TRUE( 528 RunExtensionSubtest("webnavigation", "test_userAction.html")) << message_; 529 530 WebContents* tab = browser()->tab_strip_model()->GetActiveWebContents(); 531 content::WaitForLoadStop(tab); 532 533 ResultCatcher catcher; 534 535 ExtensionService* service = extensions::ExtensionSystem::Get( 536 browser()->profile())->extension_service(); 537 const extensions::Extension* extension = 538 service->GetExtensionById(last_loaded_extension_id_, false); 539 GURL url = extension->GetResourceURL("userAction/a.html"); 540 541 ui_test_utils::NavigateToURL(browser(), url); 542 543 // This corresponds to "Open link in new tab". 544 content::ContextMenuParams params; 545 params.is_editable = false; 546 params.media_type = WebKit::WebContextMenuData::MediaTypeNone; 547 params.page_url = url; 548 params.frame_id = WebNavigationTabObserver::Get(tab)-> 549 frame_navigation_state().GetMainFrameID().frame_num; 550 params.link_url = extension->GetResourceURL("userAction/b.html"); 551 552 TestRenderViewContextMenu menu(tab, params); 553 menu.Init(); 554 menu.ExecuteCommand(IDC_CONTENT_CONTEXT_OPENLINKNEWTAB, 0); 555 556 ASSERT_TRUE(catcher.GetNextResult()) << catcher.message(); 557 } 558 559 // http://crbug.com/177163 560 #if defined(OS_WIN) && !defined(NDEBUG) 561 #define MAYBE_RequestOpenTab DISABLED_RequestOpenTab 562 #else 563 #define MAYBE_RequestOpenTab RequestOpenTab 564 #endif 565 IN_PROC_BROWSER_TEST_F(WebNavigationApiTest, MAYBE_RequestOpenTab) { 566 ASSERT_TRUE(StartEmbeddedTestServer()); 567 568 // Wait for the extension to set itself up and return control to us. 569 ASSERT_TRUE(RunExtensionSubtest("webnavigation", "test_requestOpenTab.html")) 570 << message_; 571 572 WebContents* tab = browser()->tab_strip_model()->GetActiveWebContents(); 573 content::WaitForLoadStop(tab); 574 575 ResultCatcher catcher; 576 577 ExtensionService* service = extensions::ExtensionSystem::Get( 578 browser()->profile())->extension_service(); 579 const extensions::Extension* extension = 580 service->GetExtensionById(last_loaded_extension_id_, false); 581 GURL url = extension->GetResourceURL("requestOpenTab/a.html"); 582 583 ui_test_utils::NavigateToURL(browser(), url); 584 585 // There's a link on a.html. Middle-click on it to open it in a new tab. 586 WebKit::WebMouseEvent mouse_event; 587 mouse_event.type = WebKit::WebInputEvent::MouseDown; 588 mouse_event.button = WebKit::WebMouseEvent::ButtonMiddle; 589 mouse_event.x = 7; 590 mouse_event.y = 7; 591 mouse_event.clickCount = 1; 592 tab->GetRenderViewHost()->ForwardMouseEvent(mouse_event); 593 mouse_event.type = WebKit::WebInputEvent::MouseUp; 594 tab->GetRenderViewHost()->ForwardMouseEvent(mouse_event); 595 596 ASSERT_TRUE(catcher.GetNextResult()) << catcher.message(); 597 } 598 599 // Fails often on Windows dbg bots. http://crbug.com/177163 600 #if defined(OS_WIN) 601 #define MAYBE_TargetBlank DISABLED_TargetBlank 602 #else 603 #define MAYBE_TargetBlank TargetBlank 604 #endif // defined(OS_WIN) 605 IN_PROC_BROWSER_TEST_F(WebNavigationApiTest, MAYBE_TargetBlank) { 606 ASSERT_TRUE(StartEmbeddedTestServer()); 607 608 // Wait for the extension to set itself up and return control to us. 609 ASSERT_TRUE(RunExtensionSubtest("webnavigation", "test_targetBlank.html")) 610 << message_; 611 612 WebContents* tab = browser()->tab_strip_model()->GetActiveWebContents(); 613 content::WaitForLoadStop(tab); 614 615 ResultCatcher catcher; 616 617 GURL url = embedded_test_server()->GetURL( 618 "/extensions/api_test/webnavigation/targetBlank/a.html"); 619 620 chrome::NavigateParams params(browser(), url, content::PAGE_TRANSITION_LINK); 621 ui_test_utils::NavigateToURL(¶ms); 622 623 // There's a link with target=_blank on a.html. Click on it to open it in a 624 // new tab. 625 WebKit::WebMouseEvent mouse_event; 626 mouse_event.type = WebKit::WebInputEvent::MouseDown; 627 mouse_event.button = WebKit::WebMouseEvent::ButtonLeft; 628 mouse_event.x = 7; 629 mouse_event.y = 7; 630 mouse_event.clickCount = 1; 631 tab->GetRenderViewHost()->ForwardMouseEvent(mouse_event); 632 mouse_event.type = WebKit::WebInputEvent::MouseUp; 633 tab->GetRenderViewHost()->ForwardMouseEvent(mouse_event); 634 635 ASSERT_TRUE(catcher.GetNextResult()) << catcher.message(); 636 } 637 638 // http://crbug.com/177163 639 #if defined(OS_WIN) && !defined(NDEBUG) 640 #define MAYBE_TargetBlankIncognito DISABLED_TargetBlankIncognito 641 #else 642 #define MAYBE_TargetBlankIncognito TargetBlankIncognito 643 #endif 644 IN_PROC_BROWSER_TEST_F(WebNavigationApiTest, MAYBE_TargetBlankIncognito) { 645 ASSERT_TRUE(StartEmbeddedTestServer()); 646 647 // Wait for the extension to set itself up and return control to us. 648 ASSERT_TRUE(RunExtensionSubtest( 649 "webnavigation", "test_targetBlank.html", 650 ExtensionApiTest::kFlagEnableIncognito)) << message_; 651 652 ResultCatcher catcher; 653 654 GURL url = embedded_test_server()->GetURL( 655 "/extensions/api_test/webnavigation/targetBlank/a.html"); 656 657 Browser* otr_browser = ui_test_utils::OpenURLOffTheRecord( 658 browser()->profile(), url); 659 WebContents* tab = otr_browser->tab_strip_model()->GetActiveWebContents(); 660 661 // There's a link with target=_blank on a.html. Click on it to open it in a 662 // new tab. 663 WebKit::WebMouseEvent mouse_event; 664 mouse_event.type = WebKit::WebInputEvent::MouseDown; 665 mouse_event.button = WebKit::WebMouseEvent::ButtonLeft; 666 mouse_event.x = 7; 667 mouse_event.y = 7; 668 mouse_event.clickCount = 1; 669 tab->GetRenderViewHost()->ForwardMouseEvent(mouse_event); 670 mouse_event.type = WebKit::WebInputEvent::MouseUp; 671 tab->GetRenderViewHost()->ForwardMouseEvent(mouse_event); 672 673 ASSERT_TRUE(catcher.GetNextResult()) << catcher.message(); 674 } 675 676 IN_PROC_BROWSER_TEST_F(WebNavigationApiTest, History) { 677 ASSERT_TRUE(StartEmbeddedTestServer()); 678 ASSERT_TRUE( 679 RunExtensionSubtest("webnavigation", "test_history.html")) 680 << message_; 681 } 682 683 IN_PROC_BROWSER_TEST_F(WebNavigationApiTest, CrossProcess) { 684 ASSERT_TRUE(StartEmbeddedTestServer()); 685 686 LoadExtension(test_data_dir_.AppendASCII("webnavigation").AppendASCII("app")); 687 LoadExtension(test_data_dir_.AppendASCII("webnavigation")); 688 689 ExtensionService* service = extensions::ExtensionSystem::Get( 690 browser()->profile())->extension_service(); 691 const extensions::Extension* extension = 692 service->GetExtensionById(last_loaded_extension_id_, false); 693 694 // See crossProcess/d.html. 695 DelayLoadStartAndExecuteJavascript call_script( 696 test_navigation_listener(), 697 embedded_test_server()->GetURL("/test1"), 698 "navigate2()", 699 extension->GetResourceURL("crossProcess/empty.html")); 700 701 ASSERT_TRUE(RunPageTest( 702 extension->GetResourceURL("test_crossProcess.html").spec())) 703 << message_; 704 } 705 706 IN_PROC_BROWSER_TEST_F(WebNavigationApiTest, CrossProcessFragment) { 707 ASSERT_TRUE(StartEmbeddedTestServer()); 708 709 LoadExtension(test_data_dir_.AppendASCII("webnavigation")); 710 711 ExtensionService* service = extensions::ExtensionSystem::Get( 712 browser()->profile())->extension_service(); 713 const extensions::Extension* extension = 714 service->GetExtensionById(last_loaded_extension_id_, false); 715 716 // See crossProcess/f.html. 717 DelayLoadStartAndExecuteJavascript call_script3( 718 test_navigation_listener(), 719 embedded_test_server()->GetURL("/test3"), 720 "updateFragment()", 721 extension->GetResourceURL(base::StringPrintf( 722 "crossProcess/f.html?%d#foo", 723 embedded_test_server()->port()))); 724 725 // See crossProcess/g.html. 726 DelayLoadStartAndExecuteJavascript call_script4( 727 test_navigation_listener(), 728 embedded_test_server()->GetURL("/test4"), 729 "updateFragment()", 730 extension->GetResourceURL(base::StringPrintf( 731 "crossProcess/g.html?%d#foo", 732 embedded_test_server()->port()))); 733 734 ASSERT_TRUE(RunPageTest( 735 extension->GetResourceURL("test_crossProcessFragment.html").spec())) 736 << message_; 737 } 738 739 IN_PROC_BROWSER_TEST_F(WebNavigationApiTest, CrossProcessHistory) { 740 ASSERT_TRUE(StartEmbeddedTestServer()); 741 742 LoadExtension(test_data_dir_.AppendASCII("webnavigation")); 743 744 ExtensionService* service = extensions::ExtensionSystem::Get( 745 browser()->profile())->extension_service(); 746 const extensions::Extension* extension = 747 service->GetExtensionById(last_loaded_extension_id_, false); 748 749 // See crossProcess/e.html. 750 DelayLoadStartAndExecuteJavascript call_script2( 751 test_navigation_listener(), 752 embedded_test_server()->GetURL("/test2"), 753 "updateHistory()", 754 extension->GetResourceURL("crossProcess/empty.html")); 755 756 // See crossProcess/h.html. 757 DelayLoadStartAndExecuteJavascript call_script5( 758 test_navigation_listener(), 759 embedded_test_server()->GetURL("/test5"), 760 "updateHistory()", 761 extension->GetResourceURL("crossProcess/empty.html")); 762 763 // See crossProcess/i.html. 764 DelayLoadStartAndExecuteJavascript call_script6( 765 test_navigation_listener(), 766 embedded_test_server()->GetURL("/test6"), 767 "updateHistory()", 768 extension->GetResourceURL("crossProcess/empty.html")); 769 770 ASSERT_TRUE(RunPageTest( 771 extension->GetResourceURL("test_crossProcessHistory.html").spec())) 772 << message_; 773 } 774 775 // http://crbug.com/177163 776 #if defined(OS_WIN) && !defined(NDEBUG) 777 #define MAYBE_Crash DISABLED_Crash 778 #else 779 #define MAYBE_Crash Crash 780 #endif 781 IN_PROC_BROWSER_TEST_F(WebNavigationApiTest, MAYBE_Crash) { 782 ASSERT_TRUE(StartEmbeddedTestServer()); 783 784 // Wait for the extension to set itself up and return control to us. 785 ASSERT_TRUE(RunExtensionSubtest("webnavigation", "test_crash.html")) 786 << message_; 787 788 WebContents* tab = browser()->tab_strip_model()->GetActiveWebContents(); 789 content::WaitForLoadStop(tab); 790 791 ResultCatcher catcher; 792 793 GURL url(base::StringPrintf( 794 "http://www.a.com:%d/" 795 "extensions/api_test/webnavigation/crash/a.html", 796 embedded_test_server()->port())); 797 ui_test_utils::NavigateToURL(browser(), url); 798 799 ui_test_utils::NavigateToURL(browser(), GURL(content::kChromeUICrashURL)); 800 801 url = GURL(base::StringPrintf( 802 "http://www.a.com:%d/" 803 "extensions/api_test/webnavigation/crash/b.html", 804 embedded_test_server()->port())); 805 ui_test_utils::NavigateToURL(browser(), url); 806 807 ASSERT_TRUE(catcher.GetNextResult()) << catcher.message(); 808 } 809 810 } // namespace extensions 811