Collect threat details for phishing and UwS

chrome/browser/safe_browsing/safe_browsing_blocking_page_test.cc

 // Copyright (c) 2012 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 known-
 // threat urls.  It then uses a real browser to go to these urls, and sends
 // "goback" or "proceed" commands and verifies they work.
 
 #include "base/bind.h"
 #include "base/command_line.h"
@@ skipping 226 matching lines @@
  public:
   FakeThreatDetails(
       SafeBrowsingUIManager* delegate,
       WebContents* web_contents,
       const SafeBrowsingUIManager::UnsafeResource& unsafe_resource)
       : ThreatDetails(delegate, web_contents, unsafe_resource),
         got_dom_(false),
         waiting_(false) {}
 
   void AddDOMDetails(
-      const std::vector<SafeBrowsingHostMsg_MalwareDOMDetails_Node>& params)
+      const std::vector<SafeBrowsingHostMsg_ThreatDOMDetails_Node>& params)
       override {
     EXPECT_TRUE(BrowserThread::CurrentlyOn(BrowserThread::IO));
     ThreatDetails::AddDOMDetails(params);
 
     // Notify the UI thread that we got the dom details.
     BrowserThread::PostTask(
         BrowserThread::UI, FROM_HERE,
         base::Bind(&FakeThreatDetails::OnDOMDetailsDone, this));
   }
 
   void WaitForDOM() {
     if (got_dom_) {
       return;
     }
     // This condition might not trigger normally, but if you add a
-    // sleep(1) in malware_dom_details it triggers :).
+    // sleep(1) in threat_dom_details it triggers :).
     waiting_ = true;
     content::RunMessageLoop();
     EXPECT_TRUE(got_dom_);
   }
 
  private:
   ~FakeThreatDetails() override {}
 
   void OnDOMDetailsDone() {
     got_dom_ = true;
@@ skipping 69 matching lines @@
  public:
   TestSafeBrowsingBlockingPageFactory() { }
   ~TestSafeBrowsingBlockingPageFactory() override {}
 
   SafeBrowsingBlockingPage* CreateSafeBrowsingPage(
       SafeBrowsingUIManager* delegate,
       WebContents* web_contents,
       const SafeBrowsingBlockingPage::UnsafeResourceList& unsafe_resources)
       override {
     return new TestSafeBrowsingBlockingPage(delegate, web_contents,
-                                              unsafe_resources);
+                                            unsafe_resources);
   }
 };
 
 }  // namespace
 
 // Tests the safe browsing blocking page in a browser.
 class SafeBrowsingBlockingPageBrowserTest
     : public InProcessBrowserTest,
       public testing::WithParamInterface<SBThreatType> {
  public:
@@ skipping 339 matching lines @@
   GURL url = SetupThreatIframeWarningAndNavigate();
 
   EXPECT_TRUE(ClickAndWaitForDetach("proceed-link"));
   AssertNoInterstitial(true);  // Assert the interstitial is gone
 
   EXPECT_EQ(url,
             browser()->tab_strip_model()->GetActiveWebContents()->GetURL());
 }
 
 IN_PROC_BROWSER_TEST_P(SafeBrowsingBlockingPageBrowserTest,
-                       IframeOptInAndReportMalwareDetails) {
+                       IframeOptInAndReportThreatDetails) {
   // The extended reporting opt-in is presented in the interstitial for malware,
-  // phishing, and UwS threats. It however only results in uploading further
-  // details about the immediate threat when facing malware threats.
-  const bool expect_malware_details = GetParam() == SB_THREAT_TYPE_URL_MALWARE;
+  // phishing, and UwS threats. This test uses malware as an example to verify
+  // this reporting functionality.
+  const bool expect_threat_details =
+      SafeBrowsingBlockingPage::ShouldReportThreatDetails(GetParam());
 
-  scoped_refptr<content::MessageLoopRunner> malware_report_sent_runner(
+  scoped_refptr<content::MessageLoopRunner> threat_report_sent_runner(
       new content::MessageLoopRunner);
-  if (expect_malware_details)
-    SetReportSentCallback(malware_report_sent_runner->QuitClosure());
+  if (expect_threat_details)
+    SetReportSentCallback(threat_report_sent_runner->QuitClosure());
 
   GURL url = SetupThreatIframeWarningAndNavigate();
 
-  FakeThreatDetails* fake_malware_details = details_factory_.get_details();
-  EXPECT_EQ(expect_malware_details, fake_malware_details != nullptr);
+  FakeThreatDetails* fake_threat_details = details_factory_.get_details();
+  EXPECT_EQ(expect_threat_details, fake_threat_details != nullptr);
 
   // If the DOM details from renderer did not already return when they are
   // expected, wait for them.
-  if (expect_malware_details)
-    fake_malware_details->WaitForDOM();
+  if (expect_threat_details)
+    fake_threat_details->WaitForDOM();
 
   EXPECT_EQ(VISIBLE, GetVisibility("extended-reporting-opt-in"));
   EXPECT_TRUE(Click("opt-in-checkbox"));
   EXPECT_TRUE(ClickAndWaitForDetach("proceed-link"));
   AssertNoInterstitial(true);  // Assert the interstitial is gone
 
   EXPECT_TRUE(browser()->profile()->GetPrefs()->GetBoolean(
               prefs::kSafeBrowsingExtendedReportingEnabled));
   EXPECT_EQ(url,
             browser()->tab_strip_model()->GetActiveWebContents()->GetURL());
 
-  if (expect_malware_details) {
-    malware_report_sent_runner->Run();
+  if (expect_threat_details) {
+    threat_report_sent_runner->Run();
     std::string serialized = GetReportSent();
-    safe_browsing::ClientMalwareReportRequest report;
+    safe_browsing::ClientSafeBrowsingReportRequest report;
     ASSERT_TRUE(report.ParseFromString(serialized));
     // Verify the report is complete.
     EXPECT_TRUE(report.complete());
   }
 }
 
 // Verifies that the "proceed anyway" link isn't available when it is disabled
 // by the corresponding policy. Also verifies that sending the "proceed"
 // command anyway doesn't advance to the unsafe site.
 IN_PROC_BROWSER_TEST_P(SafeBrowsingBlockingPageBrowserTest, ProceedDisabled) {
@@ skipping 258 matching lines @@
 IN_PROC_BROWSER_TEST_P(SafeBrowsingBlockingPageIDNTest,
                        SafeBrowsingBlockingPageDecodesIDN) {
   EXPECT_TRUE(VerifyIDNDecoded());
 }
 
 INSTANTIATE_TEST_CASE_P(SafeBrowsingBlockingPageIDNTestWithThreatType,
                         SafeBrowsingBlockingPageIDNTest,
                         testing::Values(SB_THREAT_TYPE_URL_MALWARE,
                                         SB_THREAT_TYPE_URL_PHISHING,
                                         SB_THREAT_TYPE_URL_UNWANTED));