The optional Malware Details also collects HTTP cache information. See design...

chrome/browser/safe_browsing/safe_browsing_blocking_page_test.cc

-// Copyright (c) 2010 The Chromium Authors. All rights reserved.
+// Copyright (c) 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 //
 // This test creates a fake safebrowsing service, where we can inject
 // malware and phishing urls.  It then uses a real browser to go to
 // these urls, and sends "goback" or "proceed" commands and verifies
 // they work.
 
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/prefs/pref_service.h"
@@ skipping 40 matching lines @@
     check.url.reset(new GURL(gurl));
     check.client = client;
     check.result = badurls[gurl.spec()];
     client->OnSafeBrowsingResult(check);
   }
 
   void AddURLResult(const GURL& url, UrlCheckResult checkresult) {
     badurls[url.spec()] = checkresult;
   }
 
-  virtual void ReportMalwareDetails(scoped_refptr<MalwareDetails> details) {
-    details_.push_back(details);
-    // Notify the UI thread, that we got a report.
-    BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
-                            NewRunnableMethod(this,
-                            &FakeSafeBrowsingService::OnMalwareDetailsDone));
+  // Overrides SafeBrowsingService.
+  virtual void SendSerializedMalwareDetails(const std::string& serialized) {
+    reports_.push_back(serialized);
+    // Notify the UI thread that we got a report.
+    BrowserThread::PostTask(
+        BrowserThread::UI, FROM_HERE,
+        NewRunnableMethod(this,
+                          &FakeSafeBrowsingService::OnMalwareDetailsDone));
   }
 
   void OnMalwareDetailsDone() {
     EXPECT_TRUE(BrowserThread::CurrentlyOn(BrowserThread::UI));
     MessageLoopForUI::current()->Quit();
   }
 
-  std::list<scoped_refptr<MalwareDetails> >* GetDetails() {
-    return &details_;
+  std::string GetReport() {
+    EXPECT_TRUE(reports_.size() == 1);
+    return reports_[0];
   }
 
-  std::list<scoped_refptr<MalwareDetails> > details_;
+  std::vector<std::string> reports_;
 
  private:
   base::hash_map<std::string, UrlCheckResult> badurls;
 };
 
 // Factory that creates FakeSafeBrowsingService instances.
 class TestSafeBrowsingServiceFactory : public SafeBrowsingServiceFactory {
  public:
   TestSafeBrowsingServiceFactory() { }
   virtual ~TestSafeBrowsingServiceFactory() { }
 
   virtual SafeBrowsingService* CreateSafeBrowsingService() {
     return new FakeSafeBrowsingService();
   }
 };
 
 // A MalwareDetails class lets us intercept calls from the renderer.
 class FakeMalwareDetails : public MalwareDetails {
  public:
-  FakeMalwareDetails(TabContents* tab_contents,
+  FakeMalwareDetails(SafeBrowsingService* sb_service,
+                     TabContents* tab_contents,
                      const SafeBrowsingService::UnsafeResource& unsafe_resource)
-      : MalwareDetails(tab_contents, unsafe_resource) { }
+      : MalwareDetails(sb_service, tab_contents, unsafe_resource) { }
 
   virtual ~FakeMalwareDetails() {}
 
   virtual void AddDOMDetails(
       const std::vector<SafeBrowsingHostMsg_MalwareDOMDetails_Node>& params) {
     EXPECT_TRUE(BrowserThread::CurrentlyOn(BrowserThread::IO));
     MalwareDetails::AddDOMDetails(params);
 
     // Notify the UI thread that we got the dom details.
     BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
@@ skipping 17 matching lines @@
   }
 
   void set_got_dom(bool got_dom) {
     got_dom_ = got_dom;
   }
 
   void set_waiting(bool waiting) {
     waiting_ = waiting;
   }
 
+  safe_browsing::ClientMalwareReportRequest* get_report() {
+    return report_.get();
+  }
+
  private:
   // Some logic to figure out if we should wait for the dom details or not.
   // These variables should only be accessed in the UI thread.
   bool got_dom_;
   bool waiting_;
 
 };
 
 class TestMalwareDetailsFactory : public MalwareDetailsFactory {
  public:
   TestMalwareDetailsFactory() { }
   virtual ~TestMalwareDetailsFactory() { }
 
   virtual MalwareDetails* CreateMalwareDetails(
+      SafeBrowsingService* sb_service,
       TabContents* tab_contents,
       const SafeBrowsingService::UnsafeResource& unsafe_resource) {
-    details_ = new FakeMalwareDetails(tab_contents, unsafe_resource);
+    details_ = new FakeMalwareDetails(sb_service, tab_contents,
+                                      unsafe_resource);
     return details_;
   }
 
   FakeMalwareDetails* get_details() {
     return details_;
   }
 
  private:
   FakeMalwareDetails* details_;
 };
 
+// A SafeBrowingBlockingPage class that lets us wait until it's hidden.
+class TestSafeBrowsingBlockingPage :  public SafeBrowsingBlockingPage {
+ public:
+  TestSafeBrowsingBlockingPage(SafeBrowsingService* service,
+                               TabContents* tab_contents,
+                               const UnsafeResourceList& unsafe_resources)
+      : SafeBrowsingBlockingPage(service, tab_contents, unsafe_resources) {
+    wait_for_delete_ = false;
+  }
+
+  ~TestSafeBrowsingBlockingPage() {
+    if (wait_for_delete_) {
+      // Notify that we are gone
+      MessageLoopForUI::current()->Quit();
+    }
+  }
+
+  void set_wait_for_delete() {
+    wait_for_delete_ = true;
+  }
+
+ private:
+  bool wait_for_delete_;
+};
+
+class TestSafeBrowsingBlockingPageFactory
+    : public SafeBrowsingBlockingPageFactory {
+ public:
+  TestSafeBrowsingBlockingPageFactory() { }
+  ~TestSafeBrowsingBlockingPageFactory() { }
+
+  virtual SafeBrowsingBlockingPage* CreateSafeBrowsingPage(
+      SafeBrowsingService* service,
+      TabContents* tab_contents,
+      const SafeBrowsingBlockingPage::UnsafeResourceList& unsafe_resources) {
+    return new TestSafeBrowsingBlockingPage(service, tab_contents,
+                                            unsafe_resources);
+  }
+};
+
 // Tests the safe browsing blocking page in a browser.
 class SafeBrowsingBlockingPageTest : public InProcessBrowserTest,
                                      public SafeBrowsingService::Client {
  public:
   SafeBrowsingBlockingPageTest() {
   }
 
   virtual void SetUp() {
     SafeBrowsingService::RegisterFactory(&factory_);
+    SafeBrowsingBlockingPage::RegisterFactory(&blocking_page_factory_);
     MalwareDetails::RegisterFactory(&details_factory_);
     InProcessBrowserTest::SetUp();
   }
 
   virtual void TearDown() {
     InProcessBrowserTest::TearDown();
+    SafeBrowsingBlockingPage::RegisterFactory(NULL);
     SafeBrowsingService::RegisterFactory(NULL);
     MalwareDetails::RegisterFactory(NULL);
   }
 
   virtual void SetUpInProcessBrowserTestFixture() {
     ASSERT_TRUE(test_server()->Start());
   }
 
   // SafeBrowsingService::Client implementation.
   virtual void OnSafeBrowsingResult(
@@ skipping 37 matching lines @@
   }
 
   void ProceedThroughInterstitial() {
     TabContents* contents = browser()->GetSelectedTabContents();
     InterstitialPage* interstitial_page = InterstitialPage::GetInterstitialPage(
         contents);
     ASSERT_TRUE(interstitial_page);
     interstitial_page->Proceed();
   }
 
-  void AssertNoInterstitial() {
-    // ui_test_utils::RunAllPendingInMessageLoop();
+  void AssertNoInterstitial(bool wait_for_delete) {
     TabContents* contents = browser()->GetSelectedTabContents();
-    InterstitialPage* interstitial_page = InterstitialPage::GetInterstitialPage(
-        contents);
-    ASSERT_FALSE(interstitial_page);
+
+    if (contents->showing_interstitial_page() && wait_for_delete) {
+      // We'll get notified when the interstitial is deleted.
+      static_cast<TestSafeBrowsingBlockingPage*>(
+          contents->interstitial_page())->set_wait_for_delete();
+      ui_test_utils::RunMessageLoop();
+    }
+
+    // Can't use InterstitialPage::GetInterstitialPage() because that
+    // gets updated after the TestSafeBrowsingBlockingPage destructor
+    ASSERT_FALSE(contents->showing_interstitial_page());
   }
 
   void WaitForNavigation() {
     NavigationController* controller =
         &browser()->GetSelectedTabContents()->controller();
     ui_test_utils::WaitForNavigation(controller);
   }
 
   void AssertReportSent() {
     // When a report is scheduled in the IO thread we should get notified.
     ui_test_utils::RunMessageLoop();
 
     FakeSafeBrowsingService* service =
         static_cast<FakeSafeBrowsingService*>(
             g_browser_process->resource_dispatcher_host()->
             safe_browsing_service());
-    ASSERT_EQ(1u, service->GetDetails()->size());
+
+    std::string serialized = service->GetReport();
+
+    safe_browsing::ClientMalwareReportRequest report;
+    ASSERT_TRUE(report.ParseFromString(serialized));
+
+    // Verify the report is complete.
+    EXPECT_TRUE(report.complete());
   }
 
  protected:
   TestMalwareDetailsFactory details_factory_;
 
  private:
   TestSafeBrowsingServiceFactory factory_;
+  TestSafeBrowsingBlockingPageFactory blocking_page_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(SafeBrowsingBlockingPageTest);
 };
 
 namespace {
 
 const char kEmptyPage[] = "files/empty.html";
 const char kMalwarePage[] = "files/safe_browsing/malware.html";
 const char kMalwareIframe[] = "files/safe_browsing/malware_iframe.html";
 
 IN_PROC_BROWSER_TEST_F(SafeBrowsingBlockingPageTest, MalwareDontProceed) {
   GURL url = test_server()->GetURL(kEmptyPage);
   AddURLResult(url, SafeBrowsingService::URL_MALWARE);
 
   ui_test_utils::NavigateToURL(browser(), url);
 
   SendCommand("\"takeMeBack\"");   // Simulate the user clicking "back"
-  AssertNoInterstitial();   // Assert the interstitial is gone
+  AssertNoInterstitial(false);   // Assert the interstitial is gone
   EXPECT_EQ(GURL(chrome::kAboutBlankURL),   // Back to "about:blank"
             browser()->GetSelectedTabContents()->GetURL());
 }
 
 IN_PROC_BROWSER_TEST_F(SafeBrowsingBlockingPageTest, MalwareProceed) {
   GURL url = test_server()->GetURL(kEmptyPage);
   AddURLResult(url, SafeBrowsingService::URL_MALWARE);
 
   ui_test_utils::NavigateToURL(browser(), url);
 
   SendCommand("\"proceed\"");    // Simulate the user clicking "proceed"
   WaitForNavigation();    // Wait until we finish the navigation.
-  AssertNoInterstitial();    // Assert the interstitial is gone.
+  AssertNoInterstitial(true);    // Assert the interstitial is gone.
   EXPECT_EQ(url, browser()->GetSelectedTabContents()->GetURL());
 }
 
 IN_PROC_BROWSER_TEST_F(SafeBrowsingBlockingPageTest, PhishingDontProceed) {
   GURL url = test_server()->GetURL(kEmptyPage);
   AddURLResult(url, SafeBrowsingService::URL_PHISHING);
 
   ui_test_utils::NavigateToURL(browser(), url);
 
   SendCommand("\"takeMeBack\"");   // Simulate the user clicking "proceed"
-  AssertNoInterstitial();    // Assert the interstitial is gone
+  AssertNoInterstitial(false);    // Assert the interstitial is gone
   EXPECT_EQ(GURL(chrome::kAboutBlankURL),  // We are back to "about:blank".
             browser()->GetSelectedTabContents()->GetURL());
 }
 
 IN_PROC_BROWSER_TEST_F(SafeBrowsingBlockingPageTest, PhishingProceed) {
   GURL url = test_server()->GetURL(kEmptyPage);
   AddURLResult(url, SafeBrowsingService::URL_PHISHING);
 
   ui_test_utils::NavigateToURL(browser(), url);
 
   SendCommand("\"proceed\"");   // Simulate the user clicking "proceed".
   WaitForNavigation();    // Wait until we finish the navigation.
-  AssertNoInterstitial();    // Assert the interstitial is gone
+  AssertNoInterstitial(true);    // Assert the interstitial is gone
   EXPECT_EQ(url, browser()->GetSelectedTabContents()->GetURL());
 }
 
 IN_PROC_BROWSER_TEST_F(SafeBrowsingBlockingPageTest, PhishingReportError) {
   GURL url = test_server()->GetURL(kEmptyPage);
   AddURLResult(url, SafeBrowsingService::URL_PHISHING);
 
   ui_test_utils::NavigateToURL(browser(), url);
 
   SendCommand("\"reportError\"");   // Simulate the user clicking "report error"
   WaitForNavigation();    // Wait until we finish the navigation.
-  AssertNoInterstitial();    // Assert the interstitial is gone
+  AssertNoInterstitial(false);    // Assert the interstitial is gone
 
   // We are in the error reporting page.
   EXPECT_EQ("/safebrowsing/report_error/",
             browser()->GetSelectedTabContents()->GetURL().path());
 }
 
 IN_PROC_BROWSER_TEST_F(SafeBrowsingBlockingPageTest, PhishingLearnMore) {
   GURL url = test_server()->GetURL(kEmptyPage);
   AddURLResult(url, SafeBrowsingService::URL_PHISHING);
 
   ui_test_utils::NavigateToURL(browser(), url);
 
   SendCommand("\"learnMore\"");   // Simulate the user clicking "learn more"
   WaitForNavigation();    // Wait until we finish the navigation.
-  AssertNoInterstitial();    // Assert the interstitial is gone
+  AssertNoInterstitial(false);    // Assert the interstitial is gone
 
   // We are in the help page.
   EXPECT_EQ("/support/bin/answer.py",
             browser()->GetSelectedTabContents()->GetURL().path());
 }
 
 IN_PROC_BROWSER_TEST_F(SafeBrowsingBlockingPageTest, MalwareIframeDontProceed) {
   GURL url = test_server()->GetURL(kMalwarePage);
   GURL iframe_url = test_server()->GetURL(kMalwareIframe);
   AddURLResult(iframe_url, SafeBrowsingService::URL_MALWARE);
 
   ui_test_utils::NavigateToURL(browser(), url);
 
   SendCommand("\"takeMeBack\"");    // Simulate the user clicking "back"
-  AssertNoInterstitial();  // Assert the interstitial is gone
+  AssertNoInterstitial(false);  // Assert the interstitial is gone
 
   EXPECT_EQ(GURL(chrome::kAboutBlankURL),    // Back to "about:blank"
             browser()->GetSelectedTabContents()->GetURL());
 }
 
 // Crashy, http://crbug.com/68834.
 IN_PROC_BROWSER_TEST_F(SafeBrowsingBlockingPageTest,
                        DISABLED_MalwareIframeProceed) {
   GURL url = test_server()->GetURL(kMalwarePage);
   GURL iframe_url = test_server()->GetURL(kMalwareIframe);
   AddURLResult(iframe_url, SafeBrowsingService::URL_MALWARE);
 
   ui_test_utils::NavigateToURL(browser(), url);
 
   SendCommand("\"proceed\"");   // Simulate the user clicking "proceed"
-  AssertNoInterstitial();    // Assert the interstitial is gone
+  AssertNoInterstitial(true);    // Assert the interstitial is gone
 
   EXPECT_EQ(url, browser()->GetSelectedTabContents()->GetURL());
 }
 
 IN_PROC_BROWSER_TEST_F(SafeBrowsingBlockingPageTest,
                        MalwareIframeReportDetails) {
   GURL url = test_server()->GetURL(kMalwarePage);
   GURL iframe_url = test_server()->GetURL(kMalwareIframe);
   AddURLResult(iframe_url, SafeBrowsingService::URL_MALWARE);
 
   ui_test_utils::NavigateToURL(browser(), url);
 
   // If the DOM details from renderer did not already return, wait for them.
   if (!details_factory_.get_details()->got_dom()) {
     // This condition might not trigger normally, but if you add a
     // sleep(1) in malware_dom_details it triggers :).
     details_factory_.get_details()->set_waiting(true);
     LOG(INFO) << "Waiting for dom details.";
     ui_test_utils::RunMessageLoop();
   } else {
     LOG(INFO) << "Already got the dom details.";
   }
 
   SendCommand("\"doReport\"");  // Simulate the user checking the checkbox.
   EXPECT_TRUE(browser()->GetProfile()->GetPrefs()->GetBoolean(
       prefs::kSafeBrowsingReportingEnabled));
 
   SendCommand("\"proceed\"");  // Simulate the user clicking "back"
-  AssertNoInterstitial();  // Assert the interstitial is gone
+  AssertNoInterstitial(true);  // Assert the interstitial is gone
 
   EXPECT_EQ(url, browser()->GetSelectedTabContents()->GetURL());
   AssertReportSent();
 }
 
 }  // namespace