chrome/browser/safe_browsing/safe_browsing_blocking_page_unittest.cc

   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
   7 #include "base/prefs/pref_service.h"
   8 #include "base/run_loop.h"
   9 #include "chrome/browser/profiles/profile.h"
  10 #include "chrome/browser/safe_browsing/malware_details.h"
  11 #include "chrome/browser/safe_browsing/safe_browsing_blocking_page.h"
  12 #include "chrome/browser/safe_browsing/safe_browsing_service.h"
  13 #include "chrome/browser/safe_browsing/ui_manager.h"
  14 #include "chrome/common/pref_names.h"
  15 #include "chrome/test/base/chrome_render_view_host_test_harness.h"
  16 #include "content/public/browser/interstitial_page.h"
  17 #include "content/public/browser/navigation_entry.h"
  18 #include "content/public/browser/render_process_host.h"
  19 #include "content/public/browser/web_contents.h"
  20 #include "content/public/test/web_contents_tester.h"
  21
  22 using content::InterstitialPage;
  23 using content::NavigationEntry;
  24 using content::WebContents;
  25 using content::WebContentsTester;
  26
  27 static const char* kGoogleURL = "http://www.google.com/";
  28 static const char* kGoodURL = "http://www.goodguys.com/";
  29 static const char* kBadURL = "http://www.badguys.com/";
  30 static const char* kBadURL2 = "http://www.badguys2.com/";
  31 static const char* kBadURL3 = "http://www.badguys3.com/";
  32
  33 namespace {
  34
  35 // A SafeBrowingBlockingPage class that does not create windows.
  36 class TestSafeBrowsingBlockingPage : public SafeBrowsingBlockingPage {
  37  public:
  38   TestSafeBrowsingBlockingPage(SafeBrowsingUIManager* manager,
  39                                  WebContents* web_contents,
  40                                  const UnsafeResourceList& unsafe_resources)
  41       : SafeBrowsingBlockingPage(manager, web_contents, unsafe_resources) {
  42     // Don't delay details at all for the unittest.
  43     malware_details_proceed_delay_ms_ = 0;
  44     DontCreateViewForTesting();
  45   }
  46 };
  47
  48 class TestSafeBrowsingUIManager: public SafeBrowsingUIManager {
  49  public:
  50   explicit TestSafeBrowsingUIManager(SafeBrowsingService* service)
  51       : SafeBrowsingUIManager(service) {
  52   }
  53
  54   virtual void SendSerializedMalwareDetails(
  55       const std::string& serialized) override {
  56     details_.push_back(serialized);
  57   }
  58
  59   std::list<std::string>* GetDetails() {
  60     return &details_;
  61   }
  62
  63  private:
  64   virtual ~TestSafeBrowsingUIManager() {}
  65
  66   std::list<std::string> details_;
  67 };
  68
  69 class TestSafeBrowsingBlockingPageFactory
  70     : public SafeBrowsingBlockingPageFactory {
  71  public:
  72   TestSafeBrowsingBlockingPageFactory() { }
  73   virtual ~TestSafeBrowsingBlockingPageFactory() { }
  74
  75   virtual SafeBrowsingBlockingPage* CreateSafeBrowsingPage(
  76       SafeBrowsingUIManager* manager,
  77       WebContents* web_contents,
  78       const SafeBrowsingBlockingPage::UnsafeResourceList& unsafe_resources)
  79       override {
  80     return new TestSafeBrowsingBlockingPage(manager, web_contents,
  81                                               unsafe_resources);
  82   }
  83 };
  84
  85 }  // namespace
  86
  87 class SafeBrowsingBlockingPageTest : public ChromeRenderViewHostTestHarness {
  88  public:
  89   // The decision the user made.
  90   enum UserResponse {
  91     PENDING,
  92     OK,
  93     CANCEL
  94   };
  95
  96   SafeBrowsingBlockingPageTest() {
  97     ResetUserResponse();
  98     // The safe browsing UI manager does not need a service for this test.
  99     ui_manager_ = new TestSafeBrowsingUIManager(NULL);
 100   }
 101
 102   virtual void SetUp() override {
 103     ChromeRenderViewHostTestHarness::SetUp();
 104     SafeBrowsingBlockingPage::RegisterFactory(&factory_);
 105     ResetUserResponse();
 106   }
 107
 108   virtual void TearDown() override {
 109     // Release the UI manager before the BrowserThreads are destroyed.
 110     ui_manager_ = NULL;
 111     SafeBrowsingBlockingPage::RegisterFactory(NULL);
 112     // Clean up singleton reference (crbug.com/110594).
 113     MalwareDetails::RegisterFactory(NULL);
 114     ChromeRenderViewHostTestHarness::TearDown();
 115   }
 116
 117   void OnBlockingPageComplete(bool proceed) {
 118     if (proceed)
 119       user_response_ = OK;
 120     else
 121       user_response_ = CANCEL;
 122   }
 123
 124   void Navigate(const char* url, int page_id) {
 125     WebContentsTester::For(web_contents())->TestDidNavigate(
 126         web_contents()->GetMainFrame(), page_id, GURL(url),
 127         ui::PAGE_TRANSITION_TYPED);
 128   }
 129
 130   void GoBack(bool is_cross_site) {
 131     NavigationEntry* entry =
 132         web_contents()->GetController().GetEntryAtOffset(-1);
 133     ASSERT_TRUE(entry);
 134     web_contents()->GetController().GoBack();
 135
 136     // The pending RVH should commit for cross-site navigations.
 137     content::RenderFrameHost* rfh = is_cross_site ?
 138         WebContentsTester::For(web_contents())->GetPendingMainFrame() :
 139         web_contents()->GetMainFrame();
 140     WebContentsTester::For(web_contents())->TestDidNavigate(
 141         rfh,
 142         entry->GetPageID(),
 143         GURL(entry->GetURL()),
 144         ui::PAGE_TRANSITION_TYPED);
 145   }
 146
 147   void ShowInterstitial(bool is_subresource, const char* url) {
 148     SafeBrowsingUIManager::UnsafeResource resource;
 149     InitResource(&resource, is_subresource, GURL(url));
 150     SafeBrowsingBlockingPage::ShowBlockingPage(ui_manager_.get(), resource);
 151   }
 152
 153   // Returns the SafeBrowsingBlockingPage currently showing or NULL if none is
 154   // showing.
 155   SafeBrowsingBlockingPage* GetSafeBrowsingBlockingPage() {
 156     InterstitialPage* interstitial =
 157         InterstitialPage::GetInterstitialPage(web_contents());
 158     if (!interstitial)
 159       return NULL;
 160     return  static_cast<SafeBrowsingBlockingPage*>(
 161         interstitial->GetDelegateForTesting());
 162   }
 163
 164   UserResponse user_response() const { return user_response_; }
 165   void ResetUserResponse() { user_response_ = PENDING; }
 166
 167   static void ProceedThroughInterstitial(
 168       SafeBrowsingBlockingPage* sb_interstitial) {
 169     sb_interstitial->interstitial_page_->Proceed();
 170     // Proceed() posts a task to update the SafeBrowsingService::Client.
 171     base::RunLoop().RunUntilIdle();
 172   }
 173
 174   static void DontProceedThroughInterstitial(
 175       SafeBrowsingBlockingPage* sb_interstitial) {
 176     sb_interstitial->interstitial_page_->DontProceed();
 177     // DontProceed() posts a task to update the SafeBrowsingService::Client.
 178     base::RunLoop().RunUntilIdle();
 179   }
 180
 181   void DontProceedThroughSubresourceInterstitial(
 182       SafeBrowsingBlockingPage* sb_interstitial) {
 183     // CommandReceived(kTakeMeBackCommand) does a back navigation for
 184     // subresource interstitials.
 185     GoBack(false);
 186     // DontProceed() posts a task to update the SafeBrowsingService::Client.
 187     base::RunLoop().RunUntilIdle();
 188   }
 189
 190   scoped_refptr<TestSafeBrowsingUIManager> ui_manager_;
 191
 192  private:
 193   void InitResource(SafeBrowsingUIManager::UnsafeResource* resource,
 194                     bool is_subresource,
 195                     const GURL& url) {
 196     resource->callback =
 197         base::Bind(&SafeBrowsingBlockingPageTest::OnBlockingPageComplete,
 198                    base::Unretained(this));
 199     resource->url = url;
 200     resource->is_subresource = is_subresource;
 201     resource->threat_type = SB_THREAT_TYPE_URL_MALWARE;
 202     resource->render_process_host_id =
 203         web_contents()->GetRenderProcessHost()->GetID();
 204     resource->render_view_id =
 205         web_contents()->GetRenderViewHost()->GetRoutingID();
 206   }
 207
 208   UserResponse user_response_;
 209   TestSafeBrowsingBlockingPageFactory factory_;
 210 };
 211
 212
 213 // Tests showing a blocking page for a malware page and not proceeding.
 214 TEST_F(SafeBrowsingBlockingPageTest, MalwarePageDontProceed) {
 215   // Enable malware details.
 216   Profile* profile = Profile::FromBrowserContext(
 217       web_contents()->GetBrowserContext());
 218   profile->GetPrefs()->SetBoolean(
 219       prefs::kSafeBrowsingExtendedReportingEnabled, true);
 220
 221   // Start a load.
 222   controller().LoadURL(GURL(kBadURL), content::Referrer(),
 223                        ui::PAGE_TRANSITION_TYPED, std::string());
 224
 225
 226   // Simulate the load causing a safe browsing interstitial to be shown.
 227   ShowInterstitial(false, kBadURL);
 228   SafeBrowsingBlockingPage* sb_interstitial =
 229       GetSafeBrowsingBlockingPage();
 230   ASSERT_TRUE(sb_interstitial);
 231
 232   base::RunLoop().RunUntilIdle();
 233
 234   // Simulate the user clicking "don't proceed".
 235   DontProceedThroughInterstitial(sb_interstitial);
 236
 237   // The interstitial should be gone.
 238   EXPECT_EQ(CANCEL, user_response());
 239   EXPECT_FALSE(GetSafeBrowsingBlockingPage());
 240
 241   // We did not proceed, the pending entry should be gone.
 242   EXPECT_FALSE(controller().GetPendingEntry());
 243
 244   // A report should have been sent.
 245   EXPECT_EQ(1u, ui_manager_->GetDetails()->size());
 246   ui_manager_->GetDetails()->clear();
 247 }
 248
 249 // Tests showing a blocking page for a malware page and then proceeding.
 250 TEST_F(SafeBrowsingBlockingPageTest, MalwarePageProceed) {
 251   // Enable malware reports.
 252   Profile* profile = Profile::FromBrowserContext(
 253       web_contents()->GetBrowserContext());
 254   profile->GetPrefs()->SetBoolean(
 255       prefs::kSafeBrowsingExtendedReportingEnabled, true);
 256
 257   // Start a load.
 258   controller().LoadURL(GURL(kBadURL), content::Referrer(),
 259                        ui::PAGE_TRANSITION_TYPED, std::string());
 260
 261   // Simulate the load causing a safe browsing interstitial to be shown.
 262   ShowInterstitial(false, kBadURL);
 263   SafeBrowsingBlockingPage* sb_interstitial =
 264       GetSafeBrowsingBlockingPage();
 265   ASSERT_TRUE(sb_interstitial);
 266
 267   // Simulate the user clicking "proceed".
 268   ProceedThroughInterstitial(sb_interstitial);
 269
 270   // The interstitial is shown until the navigation commits.
 271   ASSERT_TRUE(InterstitialPage::GetInterstitialPage(web_contents()));
 272   // Commit the navigation.
 273   Navigate(kBadURL, 1);
 274   // The interstitial should be gone now.
 275   ASSERT_FALSE(InterstitialPage::GetInterstitialPage(web_contents()));
 276
 277   // A report should have been sent.
 278   EXPECT_EQ(1u, ui_manager_->GetDetails()->size());
 279   ui_manager_->GetDetails()->clear();
 280 }
 281
 282 // Tests showing a blocking page for a page that contains malware subresources
 283 // and not proceeding.
 284 TEST_F(SafeBrowsingBlockingPageTest, PageWithMalwareResourceDontProceed) {
 285   // Enable malware reports.
 286   Profile* profile = Profile::FromBrowserContext(
 287       web_contents()->GetBrowserContext());
 288   profile->GetPrefs()->SetBoolean(
 289       prefs::kSafeBrowsingExtendedReportingEnabled, true);
 290
 291   // Navigate somewhere.
 292   Navigate(kGoogleURL, 1);
 293
 294   // Navigate somewhere else.
 295   Navigate(kGoodURL, 2);
 296
 297   // Simulate that page loading a bad-resource triggering an interstitial.
 298   ShowInterstitial(true, kBadURL);
 299
 300   SafeBrowsingBlockingPage* sb_interstitial =
 301       GetSafeBrowsingBlockingPage();
 302   ASSERT_TRUE(sb_interstitial);
 303
 304   // Simulate the user clicking "don't proceed".
 305   DontProceedThroughSubresourceInterstitial(sb_interstitial);
 306   EXPECT_EQ(CANCEL, user_response());
 307   EXPECT_FALSE(GetSafeBrowsingBlockingPage());
 308
 309   // We did not proceed, we should be back to the first page, the 2nd one should
 310   // have been removed from the navigation controller.
 311   ASSERT_EQ(1, controller().GetEntryCount());
 312   EXPECT_EQ(kGoogleURL, controller().GetActiveEntry()->GetURL().spec());
 313
 314   // A report should have been sent.
 315   EXPECT_EQ(1u, ui_manager_->GetDetails()->size());
 316   ui_manager_->GetDetails()->clear();
 317 }
 318
 319 // Tests showing a blocking page for a page that contains malware subresources
 320 // and proceeding.
 321 TEST_F(SafeBrowsingBlockingPageTest, PageWithMalwareResourceProceed) {
 322   // Enable malware reports.
 323   Profile* profile = Profile::FromBrowserContext(
 324       web_contents()->GetBrowserContext());
 325   profile->GetPrefs()->SetBoolean(
 326       prefs::kSafeBrowsingExtendedReportingEnabled, true);
 327
 328   // Navigate somewhere.
 329   Navigate(kGoodURL, 1);
 330
 331   // Simulate that page loading a bad-resource triggering an interstitial.
 332   ShowInterstitial(true, kBadURL);
 333
 334   SafeBrowsingBlockingPage* sb_interstitial =
 335       GetSafeBrowsingBlockingPage();
 336   ASSERT_TRUE(sb_interstitial);
 337
 338   // Simulate the user clicking "proceed".
 339   ProceedThroughInterstitial(sb_interstitial);
 340   EXPECT_EQ(OK, user_response());
 341   EXPECT_FALSE(GetSafeBrowsingBlockingPage());
 342
 343   // We did proceed, we should be back to showing the page.
 344   ASSERT_EQ(1, controller().GetEntryCount());
 345   EXPECT_EQ(kGoodURL, controller().GetActiveEntry()->GetURL().spec());
 346
 347   // A report should have been sent.
 348   EXPECT_EQ(1u, ui_manager_->GetDetails()->size());
 349   ui_manager_->GetDetails()->clear();
 350 }
 351
 352 // Tests showing a blocking page for a page that contains multiple malware
 353 // subresources and not proceeding.  This just tests that the extra malware
 354 // subresources (which trigger queued interstitial pages) do not break anything.
 355 TEST_F(SafeBrowsingBlockingPageTest,
 356        PageWithMultipleMalwareResourceDontProceed) {
 357   // Enable malware reports.
 358   Profile* profile = Profile::FromBrowserContext(
 359       web_contents()->GetBrowserContext());
 360   profile->GetPrefs()->SetBoolean(
 361       prefs::kSafeBrowsingExtendedReportingEnabled, true);
 362
 363   // Navigate somewhere.
 364   Navigate(kGoogleURL, 1);
 365
 366   // Navigate somewhere else.
 367   Navigate(kGoodURL, 2);
 368
 369   // Simulate that page loading a bad-resource triggering an interstitial.
 370   ShowInterstitial(true, kBadURL);
 371
 372   // More bad resources loading causing more interstitials. The new
 373   // interstitials should be queued.
 374   ShowInterstitial(true, kBadURL2);
 375   ShowInterstitial(true, kBadURL3);
 376
 377   SafeBrowsingBlockingPage* sb_interstitial =
 378       GetSafeBrowsingBlockingPage();
 379   ASSERT_TRUE(sb_interstitial);
 380
 381   // Simulate the user clicking "don't proceed".
 382   DontProceedThroughSubresourceInterstitial(sb_interstitial);
 383   EXPECT_EQ(CANCEL, user_response());
 384   EXPECT_FALSE(GetSafeBrowsingBlockingPage());
 385
 386   // We did not proceed, we should be back to the first page, the 2nd one should
 387   // have been removed from the navigation controller.
 388   ASSERT_EQ(1, controller().GetEntryCount());
 389   EXPECT_EQ(kGoogleURL, controller().GetActiveEntry()->GetURL().spec());
 390
 391   // A report should have been sent.
 392   EXPECT_EQ(1u, ui_manager_->GetDetails()->size());
 393   ui_manager_->GetDetails()->clear();
 394 }
 395
 396 // Tests showing a blocking page for a page that contains multiple malware
 397 // subresources and proceeding through the first interstitial, but not the next.
 398 TEST_F(SafeBrowsingBlockingPageTest,
 399        PageWithMultipleMalwareResourceProceedThenDontProceed) {
 400   // Enable malware reports.
 401   Profile* profile = Profile::FromBrowserContext(
 402       web_contents()->GetBrowserContext());
 403   profile->GetPrefs()->SetBoolean(
 404       prefs::kSafeBrowsingExtendedReportingEnabled, true);
 405
 406   // Navigate somewhere.
 407   Navigate(kGoogleURL, 1);
 408
 409   // Navigate somewhere else.
 410   Navigate(kGoodURL, 2);
 411
 412   // Simulate that page loading a bad-resource triggering an interstitial.
 413   ShowInterstitial(true, kBadURL);
 414
 415   // More bad resources loading causing more interstitials. The new
 416   // interstitials should be queued.
 417   ShowInterstitial(true, kBadURL2);
 418   ShowInterstitial(true, kBadURL3);
 419
 420   SafeBrowsingBlockingPage* sb_interstitial =
 421       GetSafeBrowsingBlockingPage();
 422   ASSERT_TRUE(sb_interstitial);
 423
 424   // Proceed through the 1st interstitial.
 425   ProceedThroughInterstitial(sb_interstitial);
 426   EXPECT_EQ(OK, user_response());
 427
 428   // A report should have been sent.
 429   EXPECT_EQ(1u, ui_manager_->GetDetails()->size());
 430   ui_manager_->GetDetails()->clear();
 431
 432   ResetUserResponse();
 433
 434   // We should land to a 2nd interstitial (aggregating all the malware resources
 435   // loaded while the 1st interstitial was showing).
 436   sb_interstitial = GetSafeBrowsingBlockingPage();
 437   ASSERT_TRUE(sb_interstitial);
 438
 439   // Don't proceed through the 2nd interstitial.
 440   DontProceedThroughSubresourceInterstitial(sb_interstitial);
 441   EXPECT_EQ(CANCEL, user_response());
 442   EXPECT_FALSE(GetSafeBrowsingBlockingPage());
 443
 444   // We did not proceed, we should be back to the first page, the 2nd one should
 445   // have been removed from the navigation controller.
 446   ASSERT_EQ(1, controller().GetEntryCount());
 447   EXPECT_EQ(kGoogleURL, controller().GetActiveEntry()->GetURL().spec());
 448
 449   // No report should have been sent -- we don't create a report the
 450   // second time.
 451   EXPECT_EQ(0u, ui_manager_->GetDetails()->size());
 452   ui_manager_->GetDetails()->clear();
 453 }
 454
 455 // Tests showing a blocking page for a page that contains multiple malware
 456 // subresources and proceeding through the multiple interstitials.
 457 TEST_F(SafeBrowsingBlockingPageTest,
 458     PageWithMultipleMalwareResourceProceed) {
 459   // Enable malware reports.
 460   Profile* profile = Profile::FromBrowserContext(
 461       web_contents()->GetBrowserContext());
 462   profile->GetPrefs()->SetBoolean(
 463       prefs::kSafeBrowsingExtendedReportingEnabled, true);
 464
 465   // Navigate somewhere else.
 466   Navigate(kGoodURL, 1);
 467
 468   // Simulate that page loading a bad-resource triggering an interstitial.
 469   ShowInterstitial(true, kBadURL);
 470
 471   // More bad resources loading causing more interstitials. The new
 472   // interstitials should be queued.
 473   ShowInterstitial(true, kBadURL2);
 474   ShowInterstitial(true, kBadURL3);
 475
 476   SafeBrowsingBlockingPage* sb_interstitial =
 477       GetSafeBrowsingBlockingPage();
 478   ASSERT_TRUE(sb_interstitial);
 479
 480   // Proceed through the 1st interstitial.
 481   ProceedThroughInterstitial(sb_interstitial);
 482   EXPECT_EQ(OK, user_response());
 483
 484   // A report should have been sent.
 485   EXPECT_EQ(1u, ui_manager_->GetDetails()->size());
 486   ui_manager_->GetDetails()->clear();
 487
 488   ResetUserResponse();
 489
 490   // We should land to a 2nd interstitial (aggregating all the malware resources
 491   // loaded while the 1st interstitial was showing).
 492   sb_interstitial = GetSafeBrowsingBlockingPage();
 493   ASSERT_TRUE(sb_interstitial);
 494
 495   // Proceed through the 2nd interstitial.
 496   ProceedThroughInterstitial(sb_interstitial);
 497   EXPECT_EQ(OK, user_response());
 498
 499   // We did proceed, we should be back to the initial page.
 500   ASSERT_EQ(1, controller().GetEntryCount());
 501   EXPECT_EQ(kGoodURL, controller().GetActiveEntry()->GetURL().spec());
 502
 503   // No report should have been sent -- we don't create a report the
 504   // second time.
 505   EXPECT_EQ(0u, ui_manager_->GetDetails()->size());
 506   ui_manager_->GetDetails()->clear();
 507 }
 508
 509 // Tests showing a blocking page then navigating back and forth to make sure the
 510 // controller entries are OK.  http://crbug.com/17627
 511 TEST_F(SafeBrowsingBlockingPageTest, NavigatingBackAndForth) {
 512   // Enable malware reports.
 513   Profile* profile = Profile::FromBrowserContext(
 514       web_contents()->GetBrowserContext());
 515   profile->GetPrefs()->SetBoolean(
 516       prefs::kSafeBrowsingExtendedReportingEnabled, true);
 517
 518   // Navigate somewhere.
 519   Navigate(kGoodURL, 1);
 520
 521   // Now navigate to a bad page triggerring an interstitial.
 522   controller().LoadURL(GURL(kBadURL), content::Referrer(),
 523                        ui::PAGE_TRANSITION_TYPED, std::string());
 524   ShowInterstitial(false, kBadURL);
 525   SafeBrowsingBlockingPage* sb_interstitial =
 526       GetSafeBrowsingBlockingPage();
 527   ASSERT_TRUE(sb_interstitial);
 528
 529   // Proceed, then navigate back.
 530   ProceedThroughInterstitial(sb_interstitial);
 531   Navigate(kBadURL, 2);  // Commit the navigation.
 532   GoBack(true);
 533
 534   // We are back on the good page.
 535   sb_interstitial = GetSafeBrowsingBlockingPage();
 536   ASSERT_FALSE(sb_interstitial);
 537   ASSERT_EQ(2, controller().GetEntryCount());
 538   EXPECT_EQ(kGoodURL, controller().GetActiveEntry()->GetURL().spec());
 539
 540   // Navigate forward to the malware URL.
 541   web_contents()->GetController().GoForward();
 542   ShowInterstitial(false, kBadURL);
 543   sb_interstitial = GetSafeBrowsingBlockingPage();
 544   ASSERT_TRUE(sb_interstitial);
 545
 546   // Let's proceed and make sure everything is OK (bug 17627).
 547   ProceedThroughInterstitial(sb_interstitial);
 548   Navigate(kBadURL, 2);  // Commit the navigation.
 549   sb_interstitial = GetSafeBrowsingBlockingPage();
 550   ASSERT_FALSE(sb_interstitial);
 551   ASSERT_EQ(2, controller().GetEntryCount());
 552   EXPECT_EQ(kBadURL, controller().GetActiveEntry()->GetURL().spec());
 553
 554   // Two reports should have been sent.
 555   EXPECT_EQ(2u, ui_manager_->GetDetails()->size());
 556   ui_manager_->GetDetails()->clear();
 557 }
 558
 559 // Tests that calling "don't proceed" after "proceed" has been called doesn't
 560 // cause problems. http://crbug.com/30079
 561 TEST_F(SafeBrowsingBlockingPageTest, ProceedThenDontProceed) {
 562   // Enable malware reports.
 563   Profile* profile = Profile::FromBrowserContext(
 564       web_contents()->GetBrowserContext());
 565   profile->GetPrefs()->SetBoolean(
 566       prefs::kSafeBrowsingExtendedReportingEnabled, true);
 567
 568   // Start a load.
 569   controller().LoadURL(GURL(kBadURL), content::Referrer(),
 570                        ui::PAGE_TRANSITION_TYPED, std::string());
 571
 572   // Simulate the load causing a safe browsing interstitial to be shown.
 573   ShowInterstitial(false, kBadURL);
 574   SafeBrowsingBlockingPage* sb_interstitial =
 575       GetSafeBrowsingBlockingPage();
 576   ASSERT_TRUE(sb_interstitial);
 577
 578   base::RunLoop().RunUntilIdle();
 579
 580   // Simulate the user clicking "proceed" then "don't proceed" (before the
 581   // interstitial is shown).
 582   sb_interstitial->interstitial_page_->Proceed();
 583   sb_interstitial->interstitial_page_->DontProceed();
 584   // Proceed() and DontProceed() post a task to update the
 585   // SafeBrowsingService::Client.
 586   base::RunLoop().RunUntilIdle();
 587
 588   // The interstitial should be gone.
 589   EXPECT_EQ(OK, user_response());
 590   EXPECT_FALSE(GetSafeBrowsingBlockingPage());
 591
 592   // Only one report should have been sent.
 593   EXPECT_EQ(1u, ui_manager_->GetDetails()->size());
 594   ui_manager_->GetDetails()->clear();
 595 }
 596
 597 // Tests showing a blocking page for a malware page with reports disabled.
 598 TEST_F(SafeBrowsingBlockingPageTest, MalwareReportsDisabled) {
 599   // Disable malware reports.
 600   Profile* profile = Profile::FromBrowserContext(
 601       web_contents()->GetBrowserContext());
 602   profile->GetPrefs()->SetBoolean(
 603       prefs::kSafeBrowsingExtendedReportingEnabled, false);
 604
 605   // Start a load.
 606   controller().LoadURL(GURL(kBadURL), content::Referrer(),
 607                        ui::PAGE_TRANSITION_TYPED, std::string());
 608
 609   // Simulate the load causing a safe browsing interstitial to be shown.
 610   ShowInterstitial(false, kBadURL);
 611   SafeBrowsingBlockingPage* sb_interstitial =
 612       GetSafeBrowsingBlockingPage();
 613   ASSERT_TRUE(sb_interstitial);
 614
 615   base::RunLoop().RunUntilIdle();
 616
 617   // Simulate the user clicking "don't proceed".
 618   DontProceedThroughInterstitial(sb_interstitial);
 619
 620   // The interstitial should be gone.
 621   EXPECT_EQ(CANCEL, user_response());
 622   EXPECT_FALSE(GetSafeBrowsingBlockingPage());
 623
 624   // We did not proceed, the pending entry should be gone.
 625   EXPECT_FALSE(controller().GetPendingEntry());
 626
 627   // No report should have been sent.
 628   EXPECT_EQ(0u, ui_manager_->GetDetails()->size());
 629   ui_manager_->GetDetails()->clear();
 630 }
 631
 632 // Test that toggling the checkbox has the anticipated effects.
 633 TEST_F(SafeBrowsingBlockingPageTest, MalwareReportsToggling) {
 634   // Disable malware reports.
 635   Profile* profile = Profile::FromBrowserContext(
 636       web_contents()->GetBrowserContext());
 637   profile->GetPrefs()->SetBoolean(
 638       prefs::kSafeBrowsingExtendedReportingEnabled, false);
 639
 640   // Start a load.
 641   controller().LoadURL(GURL(kBadURL), content::Referrer(),
 642                        ui::PAGE_TRANSITION_TYPED, std::string());
 643
 644   // Simulate the load causing a safe browsing interstitial to be shown.
 645   ShowInterstitial(false, kBadURL);
 646   SafeBrowsingBlockingPage* sb_interstitial =
 647       GetSafeBrowsingBlockingPage();
 648   ASSERT_TRUE(sb_interstitial);
 649
 650   base::RunLoop().RunUntilIdle();
 651
 652   EXPECT_FALSE(profile->GetPrefs()->GetBoolean(
 653       prefs::kSafeBrowsingExtendedReportingEnabled));
 654
 655   // Simulate the user check the report agreement checkbox.
 656   sb_interstitial->SetReportingPreference(true);
 657
 658   EXPECT_TRUE(profile->GetPrefs()->GetBoolean(
 659       prefs::kSafeBrowsingExtendedReportingEnabled));
 660
 661   // Simulate the user uncheck the report agreement checkbox.
 662   sb_interstitial->SetReportingPreference(false);
 663
 664   EXPECT_FALSE(profile->GetPrefs()->GetBoolean(
 665       prefs::kSafeBrowsingExtendedReportingEnabled));
 666 }