Update ThreatDOMDetails to be able to collect non-resource HTML Elements based on their attributes.

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 <algorithm>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/macros.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/test/histogram_tester.h"
-#include "base/test/scoped_feature_list.h"
 #include "base/values.h"
 #include "build/build_config.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/interstitials/security_interstitial_page_test_utils.h"
 #include "chrome/browser/net/url_request_mock_util.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/safe_browsing/local_database_manager.h"
 #include "chrome/browser/safe_browsing/safe_browsing_blocking_page.h"
 #include "chrome/browser/safe_browsing/test_safe_browsing_service.h"
 #include "chrome/browser/safe_browsing/threat_details.h"
@@ skipping 25 matching lines @@
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/security_style_explanations.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/test/browser_test_utils.h"
 #include "content/public/test/test_browser_thread.h"
 #include "content/public/test/test_utils.h"
 #include "net/cert/cert_verify_result.h"
 #include "net/cert/mock_cert_verifier.h"
 #include "net/test/embedded_test_server/embedded_test_server.h"
 #include "net/test/url_request/url_request_mock_http_job.h"
+#include "testing/gmock/include/gmock/gmock-matchers.h"
 #include "ui/base/l10n/l10n_util.h"
 
 using chrome_browser_interstitials::SecurityInterstitialIDNTest;
 using content::BrowserThread;
 using content::InterstitialPage;
 using content::NavigationController;
 using content::RenderFrameHost;
 using content::WebContents;
 using security_interstitials::SafeBrowsingErrorUI;
 
@@ skipping 247 matching lines @@
     // Test UI manager and test database manager should be set before
     // InProcessBrowserTest::SetUp().
     factory_.SetTestUIManager(new FakeSafeBrowsingUIManager());
     factory_.SetTestDatabaseManager(new FakeSafeBrowsingDatabaseManager());
     SafeBrowsingService::RegisterFactory(&factory_);
     SafeBrowsingBlockingPage::RegisterFactory(&blocking_page_factory_);
     ThreatDetails::RegisterFactory(&details_factory_);
     InProcessBrowserTest::SetUp();
   }
 
-  void SetUpInProcessBrowserTestFixture() override {
-    feature_list_.reset(new base::test::ScopedFeatureList);
-    feature_list_->InitAndEnableFeature(kFillDOMInThreatDetails);
-  }
-
   void TearDown() override {
     InProcessBrowserTest::TearDown();
     SafeBrowsingBlockingPage::RegisterFactory(NULL);
     SafeBrowsingService::RegisterFactory(NULL);
     ThreatDetails::RegisterFactory(NULL);
   }
 
   void SetUpCommandLine(base::CommandLine* command_line) override {
+    command_line->AppendSwitchASCII(
+        "enable-features",
+        "FillDOMInThreatDetails,ThreatDomDetailsTagAttributes<SBDomStudy");
+    command_line->AppendSwitchASCII("force-fieldtrials",
+                                    "SBDomStudy/SBDomGroup");
+    command_line->AppendSwitchASCII(
+        "force-fieldtrial-params",
+        "SBDomStudy.SBDomGroup:tag_attribute_csv/div%2Cfoo%2Cdiv%2Cbaz");
+
     if (testing::get<1>(GetParam()))
       content::IsolateAllSitesForTesting(command_line);
   }
 
   void SetUpOnMainThread() override {
     BrowserThread::PostTask(
         BrowserThread::IO, FROM_HERE,
         base::Bind(&chrome_browser_net::SetUrlRequestMocksEnabled, true));
   }
 
@@ skipping 251 matching lines @@
         break;
       }
     }
     EXPECT_EQ(expected_child_size, actual_resource.child_ids_size());
     EXPECT_EQ(expected_tag_name, actual_resource.tag_name());
   }
 
   void VerifyElement(const ClientSafeBrowsingReportRequest& report,
                      const HTMLElement& actual_element,
                      const std::string& expected_url,
-                     const std::string& expected_tag_name) {
-    ASSERT_EQ(1, actual_element.attribute_size());
-    EXPECT_EQ(expected_url, actual_element.attribute(0).value());
+                     const std::string& expected_tag_name,
+                     const int expected_child_ids_size) {
+    if (!expected_url.empty()) {
+      ASSERT_EQ(1, actual_element.attribute_size());
+      EXPECT_EQ(expected_url, actual_element.attribute(0).value());
+    }
     EXPECT_EQ(expected_tag_name, actual_element.tag());
+    EXPECT_EQ(expected_child_ids_size, actual_element.child_ids_size());
   }
 
   void ExpectSecurityIndicatorDowngrade(content::WebContents* tab,
                                         net::CertStatus cert_status) {
     SecurityStateTabHelper* helper =
         SecurityStateTabHelper::FromWebContents(tab);
     ASSERT_TRUE(helper);
     security_state::SecurityInfo security_info;
     helper->GetSecurityInfo(&security_info);
     EXPECT_EQ(security_state::DANGEROUS, security_info.security_level);
@@ skipping 24 matching lines @@
   GURL SetupWarningAndNavigateToURL(GURL url) {
     SetURLThreatType(url, testing::get<0>(GetParam()));
     ui_test_utils::NavigateToURL(browser(), url);
     EXPECT_TRUE(WaitForReady());
     return url;
   }
 
   TestSafeBrowsingServiceFactory factory_;
   TestSafeBrowsingBlockingPageFactory blocking_page_factory_;
   net::EmbeddedTestServer https_server_;
-  std::unique_ptr<base::test::ScopedFeatureList> feature_list_;
 
   DISALLOW_COPY_AND_ASSIGN(SafeBrowsingBlockingPageBrowserTest);
 };
 
 // TODO(linux_aura) https://crbug.com/163931
 // TODO(win_aura) https://crbug.com/154081
 #if defined(USE_AURA) && !defined(OS_CHROMEOS)
 #define MAYBE_RedirectInIFrameCanceled DISABLED_RedirectInIFrameCanceled
 #else
 #define MAYBE_RedirectInIFrameCanceled RedirectInIFrameCanceled
@@ skipping 124 matching lines @@
         report, resources[0],
         net::URLRequestMockHTTPJob::GetMockUrl(kCrossSiteMaliciousPage).spec(),
         net::URLRequestMockHTTPJob::GetMockUrl(kCrossSiteMaliciousPage).spec(),
         1, "");
     VerifyResource(
         report, resources[1],
         net::URLRequestMockHTTPJob::GetMockUrl(kMaliciousIframe).spec(),
         url.spec(),  // kCrossSiteMaliciousPage
         0, "IFRAME");
 
-    ASSERT_EQ(1, report.dom_size());
-    VerifyElement(
-        report, report.dom(0),
-        net::URLRequestMockHTTPJob::GetMockUrl(kMaliciousIframe).spec(),
-        "IFRAME");
+    ASSERT_EQ(2, report.dom_size());
+    // Because the order of elements is not deterministic, we basically need to
+    // verify the relationship. Namely that there is an IFRAME element and that
+    // its has a DIV as its parent.
+    int iframe_node_id = -1;
+    for (const HTMLElement& elem : report.dom()) {
+      if (elem.tag() == "IFRAME") {
+        iframe_node_id = elem.id();
+        VerifyElement(
+            report, elem,
+            net::URLRequestMockHTTPJob::GetMockUrl(kMaliciousIframe).spec(),
+            "IFRAME", /*child_size=*/0);
+        break;
+      }
+    }
+    EXPECT_GT(iframe_node_id, -1);
+
+    // Find the parent DIV that is the parent of the iframe.
+    // TODO(lpz): Test the identify of the DIV once we start collecting its
+    // attributes.
+    for (const HTMLElement& elem : report.dom()) {
+      if (elem.id() != iframe_node_id) {
+        // Not the IIFRAME, so this is the parent DIV
+        VerifyElement(report, elem, /*url=*/"", "DIV", /*child_size=*/1);
+        // Make sure this DIV has the IFRAME as a child.
+        EXPECT_EQ(iframe_node_id, elem.child_ids(0));
+      }
+    }
   }
 }
 
 IN_PROC_BROWSER_TEST_P(SafeBrowsingBlockingPageBrowserTest,
                        MainFrameBlockedShouldHaveNoDOMDetailsWhenDontProceed) {
   const bool expect_threat_details =
       SafeBrowsingBlockingPage::ShouldReportThreatDetails(
           testing::get<0>(GetParam()));
 
   scoped_refptr<content::MessageLoopRunner> threat_report_sent_runner(
@@ skipping 579 matching lines @@
 
 INSTANTIATE_TEST_CASE_P(
     SafeBrowsingBlockingPageIDNTestWithThreatType,
     SafeBrowsingBlockingPageIDNTest,
     testing::Combine(testing::Values(false, true),
                      testing::Values(SB_THREAT_TYPE_URL_MALWARE,
                                      SB_THREAT_TYPE_URL_PHISHING,
                                      SB_THREAT_TYPE_URL_UNWANTED)));
 
 }  // namespace safe_browsing