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 "base/bind.h" 6#include "base/prefs/pref_service.h" 7#include "base/strings/string_number_conversions.h" 8#include "base/strings/utf_string_conversions.h" 9#include "chrome/app/chrome_command_ids.h" 10#include "chrome/browser/chrome_notification_types.h" 11#include "chrome/browser/renderer_context_menu/render_view_context_menu.h" 12#include "chrome/browser/renderer_context_menu/render_view_context_menu_browsertest_util.h" 13#include "chrome/browser/ui/browser.h" 14#include "chrome/browser/ui/browser_commands.h" 15#include "chrome/browser/ui/tabs/tab_strip_model.h" 16#include "chrome/common/pref_names.h" 17#include "chrome/test/base/in_process_browser_test.h" 18#include "chrome/test/base/ui_test_utils.h" 19#include "content/public/browser/navigation_controller.h" 20#include "content/public/browser/navigation_entry.h" 21#include "content/public/browser/notification_service.h" 22#include "content/public/browser/render_view_host.h" 23#include "content/public/browser/web_contents.h" 24#include "content/public/test/browser_test_utils.h" 25#include "net/test/spawned_test_server/spawned_test_server.h" 26#include "third_party/WebKit/public/web/WebInputEvent.h" 27 28namespace { 29 30const base::FilePath::CharType kDocRoot[] = 31 FILE_PATH_LITERAL("chrome/test/data/referrer_policy"); 32 33} // namespace 34 35class ReferrerPolicyTest : public InProcessBrowserTest { 36 public: 37 ReferrerPolicyTest() {} 38 virtual ~ReferrerPolicyTest() {} 39 40 virtual void SetUp() OVERRIDE { 41 test_server_.reset(new net::SpawnedTestServer( 42 net::SpawnedTestServer::TYPE_HTTP, 43 net::SpawnedTestServer::kLocalhost, 44 base::FilePath(kDocRoot))); 45 ASSERT_TRUE(test_server_->Start()); 46 ssl_test_server_.reset(new net::SpawnedTestServer( 47 net::SpawnedTestServer::TYPE_HTTPS, 48 net::SpawnedTestServer::kLocalhost, 49 base::FilePath(kDocRoot))); 50 ASSERT_TRUE(ssl_test_server_->Start()); 51 52 InProcessBrowserTest::SetUp(); 53 } 54 55 protected: 56 enum ExpectedReferrer { 57 EXPECT_EMPTY_REFERRER, 58 EXPECT_FULL_REFERRER, 59 EXPECT_ORIGIN_AS_REFERRER 60 }; 61 62 // Returns the expected title for the tab with the given (full) referrer and 63 // the expected modification of it. 64 base::string16 GetExpectedTitle(const GURL& url, 65 ExpectedReferrer expected_referrer) { 66 std::string referrer; 67 switch (expected_referrer) { 68 case EXPECT_EMPTY_REFERRER: 69 referrer = "Referrer is empty"; 70 break; 71 case EXPECT_FULL_REFERRER: 72 referrer = "Referrer is " + url.spec(); 73 break; 74 case EXPECT_ORIGIN_AS_REFERRER: 75 referrer = "Referrer is " + url.GetWithEmptyPath().spec(); 76 break; 77 } 78 return base::ASCIIToUTF16(referrer); 79 } 80 81 // Adds all possible titles to the TitleWatcher, so we don't time out 82 // waiting for the title if the test fails. 83 void AddAllPossibleTitles(const GURL& url, 84 content::TitleWatcher* title_watcher) { 85 title_watcher->AlsoWaitForTitle( 86 GetExpectedTitle(url, EXPECT_EMPTY_REFERRER)); 87 title_watcher->AlsoWaitForTitle( 88 GetExpectedTitle(url, EXPECT_FULL_REFERRER)); 89 title_watcher->AlsoWaitForTitle( 90 GetExpectedTitle(url, EXPECT_ORIGIN_AS_REFERRER)); 91 } 92 93 // Returns a string representation of a given |referrer_policy|. 94 std::string ReferrerPolicyToString(blink::WebReferrerPolicy referrer_policy) { 95 switch (referrer_policy) { 96 case blink::WebReferrerPolicyDefault: 97 return "default"; 98 case blink::WebReferrerPolicyOrigin: 99 return "origin"; 100 case blink::WebReferrerPolicyAlways: 101 return "always"; 102 case blink::WebReferrerPolicyNever: 103 return "never"; 104 default: 105 NOTREACHED(); 106 return ""; 107 } 108 } 109 110 enum StartOnProtocol { START_ON_HTTP, START_ON_HTTPS, }; 111 112 enum LinkType { REGULAR_LINK, LINK_WITH_TARGET_BLANK, }; 113 114 enum RedirectType { NO_REDIRECT, SERVER_REDIRECT, SERVER_REDIRECT_ON_HTTP, }; 115 116 std::string RedirectTypeToString(RedirectType redirect) { 117 switch (redirect) { 118 case NO_REDIRECT: 119 return "none"; 120 case SERVER_REDIRECT: 121 return "https"; 122 case SERVER_REDIRECT_ON_HTTP: 123 return "http"; 124 } 125 NOTREACHED(); 126 return ""; 127 } 128 129 // Navigates from a page with a given |referrer_policy| and checks that the 130 // reported referrer matches the expectation. 131 // Parameters: 132 // referrer_policy: The referrer policy to test. 133 // start_protocol: The protocol the test should start on. 134 // link_type: The link type that is used to trigger the navigation. 135 // redirect: Whether the link target should redirect and how. 136 // disposition: The disposition for the navigation. 137 // button: If not WebMouseEvent::ButtonNone, click on the 138 // link with the specified mouse button. 139 // expected_referrer: The kind of referrer to expect. 140 // 141 // Returns: 142 // The URL of the first page navigated to. 143 GURL RunReferrerTest(const blink::WebReferrerPolicy referrer_policy, 144 StartOnProtocol start_protocol, 145 LinkType link_type, 146 RedirectType redirect, 147 WindowOpenDisposition disposition, 148 blink::WebMouseEvent::Button button, 149 ExpectedReferrer expected_referrer) { 150 GURL start_url; 151 net::SpawnedTestServer* start_server = start_protocol == START_ON_HTTPS 152 ? ssl_test_server_.get() 153 : test_server_.get(); 154 start_url = start_server->GetURL( 155 std::string("files/referrer-policy-start.html?") + "policy=" + 156 ReferrerPolicyToString(referrer_policy) + "&port=" + 157 base::IntToString(test_server_->host_port_pair().port()) + 158 "&ssl_port=" + 159 base::IntToString(ssl_test_server_->host_port_pair().port()) + 160 "&redirect=" + RedirectTypeToString(redirect) + "&link=" + 161 (button == blink::WebMouseEvent::ButtonNone ? "false" : "true") + 162 "&target=" + (link_type == LINK_WITH_TARGET_BLANK ? "_blank" : "")); 163 164 ui_test_utils::WindowedTabAddedNotificationObserver tab_added_observer( 165 content::NotificationService::AllSources()); 166 167 base::string16 expected_title = 168 GetExpectedTitle(start_url, expected_referrer); 169 content::WebContents* tab = 170 browser()->tab_strip_model()->GetActiveWebContents(); 171 content::TitleWatcher title_watcher(tab, expected_title); 172 173 // Watch for all possible outcomes to avoid timeouts if something breaks. 174 AddAllPossibleTitles(start_url, &title_watcher); 175 176 ui_test_utils::NavigateToURL(browser(), start_url); 177 178 if (button != blink::WebMouseEvent::ButtonNone) { 179 blink::WebMouseEvent mouse_event; 180 mouse_event.type = blink::WebInputEvent::MouseDown; 181 mouse_event.button = button; 182 mouse_event.x = 15; 183 mouse_event.y = 15; 184 mouse_event.clickCount = 1; 185 tab->GetRenderViewHost()->ForwardMouseEvent(mouse_event); 186 mouse_event.type = blink::WebInputEvent::MouseUp; 187 tab->GetRenderViewHost()->ForwardMouseEvent(mouse_event); 188 } 189 190 if (disposition == CURRENT_TAB) { 191 EXPECT_EQ(expected_title, title_watcher.WaitAndGetTitle()); 192 } else { 193 tab_added_observer.Wait(); 194 tab = tab_added_observer.GetTab(); 195 EXPECT_TRUE(tab); 196 content::TitleWatcher title_watcher2(tab, expected_title); 197 198 // Watch for all possible outcomes to avoid timeouts if something breaks. 199 AddAllPossibleTitles(start_url, &title_watcher2); 200 201 EXPECT_EQ(expected_title, title_watcher2.WaitAndGetTitle()); 202 } 203 204 EXPECT_EQ(referrer_policy, 205 tab->GetController().GetActiveEntry()->GetReferrer().policy); 206 207 return start_url; 208 } 209 210 scoped_ptr<net::SpawnedTestServer> test_server_; 211 scoped_ptr<net::SpawnedTestServer> ssl_test_server_; 212}; 213 214// The basic behavior of referrer policies is covered by layout tests in 215// http/tests/security/referrer-policy-*. These tests cover (hopefully) all 216// code paths chrome uses to navigate. To keep the number of combinations down, 217// we only test the "origin" policy here. 218// 219// Some tests are marked as FAILS, see http://crbug.com/124750 220 221// Content initiated navigation, from HTTP to HTTP. 222IN_PROC_BROWSER_TEST_F(ReferrerPolicyTest, Origin) { 223 RunReferrerTest(blink::WebReferrerPolicyOrigin, 224 START_ON_HTTP, 225 REGULAR_LINK, 226 NO_REDIRECT, 227 CURRENT_TAB, 228 blink::WebMouseEvent::ButtonNone, 229 EXPECT_ORIGIN_AS_REFERRER); 230} 231 232// Content initiated navigation, from HTTPS to HTTP. 233IN_PROC_BROWSER_TEST_F(ReferrerPolicyTest, HttpsDefault) { 234 RunReferrerTest(blink::WebReferrerPolicyOrigin, 235 START_ON_HTTPS, 236 REGULAR_LINK, 237 NO_REDIRECT, 238 CURRENT_TAB, 239 blink::WebMouseEvent::ButtonNone, 240 EXPECT_ORIGIN_AS_REFERRER); 241} 242 243// User initiated navigation, from HTTP to HTTP. 244IN_PROC_BROWSER_TEST_F(ReferrerPolicyTest, LeftClickOrigin) { 245 RunReferrerTest(blink::WebReferrerPolicyOrigin, 246 START_ON_HTTP, 247 REGULAR_LINK, 248 NO_REDIRECT, 249 CURRENT_TAB, 250 blink::WebMouseEvent::ButtonLeft, 251 EXPECT_ORIGIN_AS_REFERRER); 252} 253 254// User initiated navigation, from HTTPS to HTTP. 255IN_PROC_BROWSER_TEST_F(ReferrerPolicyTest, HttpsLeftClickOrigin) { 256 RunReferrerTest(blink::WebReferrerPolicyOrigin, 257 START_ON_HTTPS, 258 REGULAR_LINK, 259 NO_REDIRECT, 260 CURRENT_TAB, 261 blink::WebMouseEvent::ButtonLeft, 262 EXPECT_ORIGIN_AS_REFERRER); 263} 264 265// User initiated navigation, middle click, from HTTP to HTTP. 266IN_PROC_BROWSER_TEST_F(ReferrerPolicyTest, MiddleClickOrigin) { 267 RunReferrerTest(blink::WebReferrerPolicyOrigin, 268 START_ON_HTTP, 269 REGULAR_LINK, 270 NO_REDIRECT, 271 NEW_BACKGROUND_TAB, 272 blink::WebMouseEvent::ButtonMiddle, 273 EXPECT_ORIGIN_AS_REFERRER); 274} 275 276// User initiated navigation, middle click, from HTTPS to HTTP. 277IN_PROC_BROWSER_TEST_F(ReferrerPolicyTest, HttpsMiddleClickOrigin) { 278 RunReferrerTest(blink::WebReferrerPolicyOrigin, 279 START_ON_HTTPS, 280 REGULAR_LINK, 281 NO_REDIRECT, 282 NEW_BACKGROUND_TAB, 283 blink::WebMouseEvent::ButtonMiddle, 284 EXPECT_ORIGIN_AS_REFERRER); 285} 286 287// User initiated navigation, target blank, from HTTP to HTTP. 288IN_PROC_BROWSER_TEST_F(ReferrerPolicyTest, TargetBlankOrigin) { 289 RunReferrerTest(blink::WebReferrerPolicyOrigin, 290 START_ON_HTTP, 291 LINK_WITH_TARGET_BLANK, 292 NO_REDIRECT, 293 NEW_FOREGROUND_TAB, 294 blink::WebMouseEvent::ButtonLeft, 295 EXPECT_ORIGIN_AS_REFERRER); 296} 297 298// User initiated navigation, target blank, from HTTPS to HTTP. 299IN_PROC_BROWSER_TEST_F(ReferrerPolicyTest, HttpsTargetBlankOrigin) { 300 RunReferrerTest(blink::WebReferrerPolicyOrigin, 301 START_ON_HTTPS, 302 LINK_WITH_TARGET_BLANK, 303 NO_REDIRECT, 304 NEW_FOREGROUND_TAB, 305 blink::WebMouseEvent::ButtonLeft, 306 EXPECT_ORIGIN_AS_REFERRER); 307} 308 309// User initiated navigation, middle click, target blank, from HTTP to HTTP. 310IN_PROC_BROWSER_TEST_F(ReferrerPolicyTest, MiddleClickTargetBlankOrigin) { 311 RunReferrerTest(blink::WebReferrerPolicyOrigin, 312 START_ON_HTTP, 313 LINK_WITH_TARGET_BLANK, 314 NO_REDIRECT, 315 NEW_FOREGROUND_TAB, 316 blink::WebMouseEvent::ButtonMiddle, 317 EXPECT_ORIGIN_AS_REFERRER); 318} 319 320// User initiated navigation, middle click, target blank, from HTTPS to HTTP. 321IN_PROC_BROWSER_TEST_F(ReferrerPolicyTest, HttpsMiddleClickTargetBlankOrigin) { 322 RunReferrerTest(blink::WebReferrerPolicyOrigin, 323 START_ON_HTTPS, 324 LINK_WITH_TARGET_BLANK, 325 NO_REDIRECT, 326 NEW_FOREGROUND_TAB, 327 blink::WebMouseEvent::ButtonMiddle, 328 EXPECT_ORIGIN_AS_REFERRER); 329} 330 331// Context menu, from HTTP to HTTP. 332IN_PROC_BROWSER_TEST_F(ReferrerPolicyTest, ContextMenuOrigin) { 333 ContextMenuNotificationObserver context_menu_observer( 334 IDC_CONTENT_CONTEXT_OPENLINKNEWTAB); 335 RunReferrerTest(blink::WebReferrerPolicyOrigin, 336 START_ON_HTTP, 337 REGULAR_LINK, 338 NO_REDIRECT, 339 NEW_FOREGROUND_TAB, 340 blink::WebMouseEvent::ButtonRight, 341 EXPECT_ORIGIN_AS_REFERRER); 342} 343 344// Context menu, from HTTPS to HTTP. 345IN_PROC_BROWSER_TEST_F(ReferrerPolicyTest, HttpsContextMenuOrigin) { 346 ContextMenuNotificationObserver context_menu_observer( 347 IDC_CONTENT_CONTEXT_OPENLINKNEWTAB); 348 RunReferrerTest(blink::WebReferrerPolicyOrigin, 349 START_ON_HTTPS, 350 REGULAR_LINK, 351 NO_REDIRECT, 352 NEW_FOREGROUND_TAB, 353 blink::WebMouseEvent::ButtonRight, 354 EXPECT_ORIGIN_AS_REFERRER); 355} 356 357// Content initiated navigation, from HTTP to HTTP via server redirect. 358IN_PROC_BROWSER_TEST_F(ReferrerPolicyTest, Redirect) { 359 RunReferrerTest(blink::WebReferrerPolicyOrigin, 360 START_ON_HTTP, 361 REGULAR_LINK, 362 SERVER_REDIRECT, 363 CURRENT_TAB, 364 blink::WebMouseEvent::ButtonNone, 365 EXPECT_ORIGIN_AS_REFERRER); 366} 367 368// Content initiated navigation, from HTTPS to HTTP via server redirect. 369IN_PROC_BROWSER_TEST_F(ReferrerPolicyTest, HttpsRedirect) { 370 RunReferrerTest(blink::WebReferrerPolicyOrigin, 371 START_ON_HTTPS, 372 REGULAR_LINK, 373 SERVER_REDIRECT, 374 CURRENT_TAB, 375 blink::WebMouseEvent::ButtonNone, 376 EXPECT_ORIGIN_AS_REFERRER); 377} 378 379// User initiated navigation, from HTTP to HTTP via server redirect. 380IN_PROC_BROWSER_TEST_F(ReferrerPolicyTest, LeftClickRedirect) { 381 RunReferrerTest(blink::WebReferrerPolicyOrigin, 382 START_ON_HTTP, 383 REGULAR_LINK, 384 SERVER_REDIRECT, 385 CURRENT_TAB, 386 blink::WebMouseEvent::ButtonLeft, 387 EXPECT_ORIGIN_AS_REFERRER); 388} 389 390// User initiated navigation, from HTTPS to HTTP via server redirect. 391IN_PROC_BROWSER_TEST_F(ReferrerPolicyTest, HttpsLeftClickRedirect) { 392 RunReferrerTest(blink::WebReferrerPolicyOrigin, 393 START_ON_HTTPS, 394 REGULAR_LINK, 395 SERVER_REDIRECT, 396 CURRENT_TAB, 397 blink::WebMouseEvent::ButtonLeft, 398 EXPECT_ORIGIN_AS_REFERRER); 399} 400 401// User initiated navigation, middle click, from HTTP to HTTP via server 402// redirect. 403IN_PROC_BROWSER_TEST_F(ReferrerPolicyTest, MiddleClickRedirect) { 404 RunReferrerTest(blink::WebReferrerPolicyOrigin, 405 START_ON_HTTP, 406 REGULAR_LINK, 407 SERVER_REDIRECT, 408 NEW_BACKGROUND_TAB, 409 blink::WebMouseEvent::ButtonMiddle, 410 EXPECT_ORIGIN_AS_REFERRER); 411} 412 413// User initiated navigation, middle click, from HTTPS to HTTP via server 414// redirect. 415IN_PROC_BROWSER_TEST_F(ReferrerPolicyTest, HttpsMiddleClickRedirect) { 416 RunReferrerTest(blink::WebReferrerPolicyOrigin, 417 START_ON_HTTPS, 418 REGULAR_LINK, 419 SERVER_REDIRECT, 420 NEW_BACKGROUND_TAB, 421 blink::WebMouseEvent::ButtonMiddle, 422 EXPECT_ORIGIN_AS_REFERRER); 423} 424 425// User initiated navigation, target blank, from HTTP to HTTP via server 426// redirect. 427IN_PROC_BROWSER_TEST_F(ReferrerPolicyTest, TargetBlankRedirect) { 428 RunReferrerTest(blink::WebReferrerPolicyOrigin, 429 START_ON_HTTP, 430 LINK_WITH_TARGET_BLANK, 431 SERVER_REDIRECT, 432 NEW_FOREGROUND_TAB, 433 blink::WebMouseEvent::ButtonLeft, 434 EXPECT_ORIGIN_AS_REFERRER); 435} 436 437// User initiated navigation, target blank, from HTTPS to HTTP via server 438// redirect. 439IN_PROC_BROWSER_TEST_F(ReferrerPolicyTest, HttpsTargetBlankRedirect) { 440 RunReferrerTest(blink::WebReferrerPolicyOrigin, 441 START_ON_HTTPS, 442 LINK_WITH_TARGET_BLANK, 443 SERVER_REDIRECT, 444 NEW_FOREGROUND_TAB, 445 blink::WebMouseEvent::ButtonLeft, 446 EXPECT_ORIGIN_AS_REFERRER); 447} 448 449// User initiated navigation, middle click, target blank, from HTTP to HTTP via 450// server redirect. 451IN_PROC_BROWSER_TEST_F(ReferrerPolicyTest, MiddleClickTargetBlankRedirect) { 452 RunReferrerTest(blink::WebReferrerPolicyOrigin, 453 START_ON_HTTP, 454 LINK_WITH_TARGET_BLANK, 455 SERVER_REDIRECT, 456 NEW_FOREGROUND_TAB, 457 blink::WebMouseEvent::ButtonMiddle, 458 EXPECT_ORIGIN_AS_REFERRER); 459} 460 461// User initiated navigation, middle click, target blank, from HTTPS to HTTP 462// via server redirect. 463IN_PROC_BROWSER_TEST_F(ReferrerPolicyTest, 464 HttpsMiddleClickTargetBlankRedirect) { 465 RunReferrerTest(blink::WebReferrerPolicyOrigin, 466 START_ON_HTTPS, 467 LINK_WITH_TARGET_BLANK, 468 SERVER_REDIRECT, 469 NEW_FOREGROUND_TAB, 470 blink::WebMouseEvent::ButtonMiddle, 471 EXPECT_ORIGIN_AS_REFERRER); 472} 473 474// Context menu, from HTTP to HTTP via server redirect. 475IN_PROC_BROWSER_TEST_F(ReferrerPolicyTest, ContextMenuRedirect) { 476 ContextMenuNotificationObserver context_menu_observer( 477 IDC_CONTENT_CONTEXT_OPENLINKNEWTAB); 478 RunReferrerTest(blink::WebReferrerPolicyOrigin, 479 START_ON_HTTP, 480 REGULAR_LINK, 481 SERVER_REDIRECT, 482 NEW_FOREGROUND_TAB, 483 blink::WebMouseEvent::ButtonRight, 484 EXPECT_ORIGIN_AS_REFERRER); 485} 486 487// Context menu, from HTTPS to HTTP via server redirect. 488IN_PROC_BROWSER_TEST_F(ReferrerPolicyTest, HttpsContextMenuRedirect) { 489 ContextMenuNotificationObserver context_menu_observer( 490 IDC_CONTENT_CONTEXT_OPENLINKNEWTAB); 491 RunReferrerTest(blink::WebReferrerPolicyOrigin, 492 START_ON_HTTPS, 493 REGULAR_LINK, 494 SERVER_REDIRECT, 495 NEW_FOREGROUND_TAB, 496 blink::WebMouseEvent::ButtonRight, 497 EXPECT_ORIGIN_AS_REFERRER); 498} 499 500// Tests history navigation actions: Navigate from A to B with a referrer 501// policy, then navigate to C, back to B, and reload. 502IN_PROC_BROWSER_TEST_F(ReferrerPolicyTest, History) { 503 // Navigate from A to B. 504 GURL start_url = RunReferrerTest(blink::WebReferrerPolicyOrigin, 505 START_ON_HTTPS, 506 REGULAR_LINK, 507 SERVER_REDIRECT, 508 CURRENT_TAB, 509 blink::WebMouseEvent::ButtonLeft, 510 EXPECT_ORIGIN_AS_REFERRER); 511 512 // Navigate to C. 513 ui_test_utils::NavigateToURL(browser(), test_server_->GetURL(std::string())); 514 515 base::string16 expected_title = 516 GetExpectedTitle(start_url, EXPECT_ORIGIN_AS_REFERRER); 517 content::WebContents* tab = 518 browser()->tab_strip_model()->GetActiveWebContents(); 519 scoped_ptr<content::TitleWatcher> title_watcher( 520 new content::TitleWatcher(tab, expected_title)); 521 522 // Watch for all possible outcomes to avoid timeouts if something breaks. 523 AddAllPossibleTitles(start_url, title_watcher.get()); 524 525 // Go back to B. 526 chrome::GoBack(browser(), CURRENT_TAB); 527 EXPECT_EQ(expected_title, title_watcher->WaitAndGetTitle()); 528 529 title_watcher.reset(new content::TitleWatcher(tab, expected_title)); 530 AddAllPossibleTitles(start_url, title_watcher.get()); 531 532 // Reload to B. 533 chrome::Reload(browser(), CURRENT_TAB); 534 EXPECT_EQ(expected_title, title_watcher->WaitAndGetTitle()); 535 536 title_watcher.reset(new content::TitleWatcher(tab, expected_title)); 537 AddAllPossibleTitles(start_url, title_watcher.get()); 538 539 // Shift-reload to B. 540 chrome::ReloadIgnoringCache(browser(), CURRENT_TAB); 541 EXPECT_EQ(expected_title, title_watcher->WaitAndGetTitle()); 542} 543 544// Tests that reloading a site for "request tablet version" correctly clears 545// the referrer. 546IN_PROC_BROWSER_TEST_F(ReferrerPolicyTest, RequestTabletSite) { 547 GURL start_url = RunReferrerTest(blink::WebReferrerPolicyOrigin, 548 START_ON_HTTPS, 549 REGULAR_LINK, 550 SERVER_REDIRECT_ON_HTTP, 551 CURRENT_TAB, 552 blink::WebMouseEvent::ButtonLeft, 553 EXPECT_ORIGIN_AS_REFERRER); 554 555 base::string16 expected_title = 556 GetExpectedTitle(start_url, EXPECT_EMPTY_REFERRER); 557 content::WebContents* tab = 558 browser()->tab_strip_model()->GetActiveWebContents(); 559 content::TitleWatcher title_watcher(tab, expected_title); 560 561 // Watch for all possible outcomes to avoid timeouts if something breaks. 562 AddAllPossibleTitles(start_url, &title_watcher); 563 564 // Request tablet version. 565 chrome::ToggleRequestTabletSite(browser()); 566 EXPECT_EQ(expected_title, title_watcher.WaitAndGetTitle()); 567} 568 569// Test that an iframes gets the parent frames referrer and referrer policy if 570// the load was triggered by the parent, or from the iframe itself, if the 571// navigations was started by the iframe. 572IN_PROC_BROWSER_TEST_F(ReferrerPolicyTest, IFrame) { 573 browser()->profile()->GetPrefs()->SetBoolean( 574 prefs::kWebKitAllowRunningInsecureContent, true); 575 content::WebContents* tab = 576 browser()->tab_strip_model()->GetActiveWebContents(); 577 base::string16 expected_title(base::ASCIIToUTF16("loaded")); 578 scoped_ptr<content::TitleWatcher> title_watcher( 579 new content::TitleWatcher(tab, expected_title)); 580 581 // Load a page that loads an iframe. 582 ui_test_utils::NavigateToURL( 583 browser(), 584 ssl_test_server_->GetURL( 585 std::string("files/referrer-policy-iframe.html?") + 586 base::IntToString(test_server_->host_port_pair().port()))); 587 EXPECT_EQ(expected_title, title_watcher->WaitAndGetTitle()); 588 589 // Verify that the referrer policy was honored and the main page's origin was 590 // send as referrer. 591 content::RenderFrameHost* frame = content::FrameMatchingPredicate( 592 tab, base::Bind(&content::FrameIsChildOfMainFrame)); 593 std::string title; 594 EXPECT_TRUE(content::ExecuteScriptAndExtractString( 595 frame, 596 "window.domAutomationController.send(document.title)", 597 &title)); 598 EXPECT_EQ("Referrer is " + ssl_test_server_->GetURL(std::string()).spec(), 599 title); 600 601 // Reload the iframe. 602 expected_title = base::ASCIIToUTF16("reset"); 603 title_watcher.reset(new content::TitleWatcher(tab, expected_title)); 604 EXPECT_TRUE(content::ExecuteScript(tab, "document.title = 'reset'")); 605 EXPECT_EQ(expected_title, title_watcher->WaitAndGetTitle()); 606 607 expected_title = base::ASCIIToUTF16("loaded"); 608 title_watcher.reset(new content::TitleWatcher(tab, expected_title)); 609 EXPECT_TRUE(content::ExecuteScript(frame, "location.reload()")); 610 EXPECT_EQ(expected_title, title_watcher->WaitAndGetTitle()); 611 612 // Verify that the full url of the iframe was used as referrer. 613 EXPECT_TRUE(content::ExecuteScriptAndExtractString( 614 frame, 615 "window.domAutomationController.send(document.title)", 616 &title)); 617 EXPECT_EQ("Referrer is " + 618 test_server_->GetURL("files/referrer-policy-log.html").spec(), 619 title); 620} 621