Move SafeBrowsingUIManager::UnsafeResource to security_interstitials namespace

chrome/browser/safe_browsing/ui_manager_unittest.cc

 // Copyright 2015 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.
 
 #include "chrome/browser/safe_browsing/ui_manager.h"
 
 #include "base/run_loop.h"
 #include "chrome/browser/safe_browsing/safe_browsing_blocking_page.h"
 #include "chrome/browser/safe_browsing/safe_browsing_service.h"
 #include "chrome/browser/safe_browsing/ui_manager.h"
@@ skipping 61 matching lines @@
   ~SafeBrowsingUIManagerTest() override{};
 
   void SetUp() override {
     SetThreadBundleOptions(content::TestBrowserThreadBundle::REAL_IO_THREAD);
     ChromeRenderViewHostTestHarness::SetUp();
     SafeBrowsingUIManager::CreateWhitelistForTesting(web_contents());
   }
 
   void TearDown() override { ChromeRenderViewHostTestHarness::TearDown(); }
 
-  bool IsWhitelisted(SafeBrowsingUIManager::UnsafeResource resource) {
+  bool IsWhitelisted(security_interstitials::UnsafeResource resource) {
     return ui_manager_->IsWhitelisted(resource);
   }
 
-  void AddToWhitelist(SafeBrowsingUIManager::UnsafeResource resource) {
+  void AddToWhitelist(security_interstitials::UnsafeResource resource) {
     ui_manager_->AddToWhitelistUrlSet(
         SafeBrowsingUIManager::GetMainFrameWhitelistUrlForResourceForTesting(
             resource),
         web_contents(), false, resource.threat_type);
   }
 
-  SafeBrowsingUIManager::UnsafeResource MakeUnsafeResource(
+  security_interstitials::UnsafeResource MakeUnsafeResource(
       const char* url,
       bool is_subresource) {
-    SafeBrowsingUIManager::UnsafeResource resource;
+    security_interstitials::UnsafeResource resource;
     resource.url = GURL(url);
     resource.is_subresource = is_subresource;
     resource.web_contents_getter =
-        SafeBrowsingUIManager::UnsafeResource::GetWebContentsGetter(
+        security_interstitials::UnsafeResource::GetWebContentsGetter(
             web_contents()->GetRenderProcessHost()->GetID(),
             web_contents()->GetMainFrame()->GetRoutingID());
     resource.threat_type = SB_THREAT_TYPE_URL_MALWARE;
     return resource;
   }
 
-  SafeBrowsingUIManager::UnsafeResource MakeUnsafeResourceAndStartNavigation(
+  security_interstitials::UnsafeResource MakeUnsafeResourceAndStartNavigation(
       const char* url) {
-    SafeBrowsingUIManager::UnsafeResource resource =
+    security_interstitials::UnsafeResource resource =
         MakeUnsafeResource(url, false /* is_subresource */);
 
     // The WC doesn't have a URL without a navigation. A main-frame malware
     // unsafe resource must be a pending navigation.
     content::WebContentsTester::For(web_contents())->StartNavigation(GURL(url));
     return resource;
   }
 
   void SimulateBlockingPageDone(
-      const std::vector<SafeBrowsingUIManager::UnsafeResource>& resources,
+      const std::vector<security_interstitials::UnsafeResource>& resources,
       bool proceed) {
     GURL main_frame_url;
     content::NavigationEntry* entry =
         web_contents()->GetController().GetVisibleEntry();
     if (entry)
       main_frame_url = entry->GetURL();
 
     ui_manager_->OnBlockingPageDone(resources, proceed, web_contents(),
                                     main_frame_url);
   }
 
  protected:
   SafeBrowsingUIManager* ui_manager() { return ui_manager_.get(); }
 
  private:
   scoped_refptr<SafeBrowsingUIManager> ui_manager_;
 };
 
 TEST_F(SafeBrowsingUIManagerTest, Whitelist) {
-  SafeBrowsingUIManager::UnsafeResource resource =
+  security_interstitials::UnsafeResource resource =
       MakeUnsafeResourceAndStartNavigation(kBadURL);
   AddToWhitelist(resource);
   EXPECT_TRUE(IsWhitelisted(resource));
 }
 
 TEST_F(SafeBrowsingUIManagerTest, WhitelistIgnoresSitesNotAdded) {
-  SafeBrowsingUIManager::UnsafeResource resource =
+  security_interstitials::UnsafeResource resource =
       MakeUnsafeResourceAndStartNavigation(kGoodURL);
   EXPECT_FALSE(IsWhitelisted(resource));
 }
 
 TEST_F(SafeBrowsingUIManagerTest, WhitelistRemembersThreatType) {
-  SafeBrowsingUIManager::UnsafeResource resource =
+  security_interstitials::UnsafeResource resource =
       MakeUnsafeResourceAndStartNavigation(kBadURL);
   AddToWhitelist(resource);
   EXPECT_TRUE(IsWhitelisted(resource));
   SBThreatType threat_type;
   content::NavigationEntry* entry =
       web_contents()->GetController().GetVisibleEntry();
   ASSERT_TRUE(entry);
   EXPECT_TRUE(ui_manager()->IsUrlWhitelistedOrPendingForWebContents(
       resource.url, resource.is_subresource, entry,
       resource.web_contents_getter.Run(), true, &threat_type));
   EXPECT_EQ(resource.threat_type, threat_type);
 }
 
 TEST_F(SafeBrowsingUIManagerTest, WhitelistIgnoresPath) {
-  SafeBrowsingUIManager::UnsafeResource resource =
+  security_interstitials::UnsafeResource resource =
       MakeUnsafeResourceAndStartNavigation(kBadURL);
   AddToWhitelist(resource);
   EXPECT_TRUE(IsWhitelisted(resource));
 
   content::WebContentsTester::For(web_contents())->CommitPendingNavigation();
 
-  SafeBrowsingUIManager::UnsafeResource resource_path =
+  security_interstitials::UnsafeResource resource_path =
       MakeUnsafeResourceAndStartNavigation(kBadURLWithPath);
   EXPECT_TRUE(IsWhitelisted(resource_path));
 }
 
 TEST_F(SafeBrowsingUIManagerTest, WhitelistIgnoresThreatType) {
-  SafeBrowsingUIManager::UnsafeResource resource =
+  security_interstitials::UnsafeResource resource =
       MakeUnsafeResourceAndStartNavigation(kBadURL);
   AddToWhitelist(resource);
   EXPECT_TRUE(IsWhitelisted(resource));
 
-  SafeBrowsingUIManager::UnsafeResource resource_phishing =
+  security_interstitials::UnsafeResource resource_phishing =
       MakeUnsafeResource(kBadURL, false /* is_subresource */);
   resource_phishing.threat_type = SB_THREAT_TYPE_URL_PHISHING;
   EXPECT_TRUE(IsWhitelisted(resource_phishing));
 }
 
 TEST_F(SafeBrowsingUIManagerTest, WhitelistWithUnrelatedPendingLoad) {
   // Commit load of landing page.
   NavigateAndCommit(GURL(kLandingURL));
   {
     // Simulate subresource malware hit on the landing page.
-    SafeBrowsingUIManager::UnsafeResource resource =
+    security_interstitials::UnsafeResource resource =
         MakeUnsafeResource(kBadURL, true /* is_subresource */);
 
     // Start pending load to unrelated site.
     content::WebContentsTester::For(web_contents())
         ->StartNavigation(GURL(kGoodURL));
 
     // Whitelist the resource on the landing page.
     AddToWhitelist(resource);
     EXPECT_TRUE(IsWhitelisted(resource));
   }
 
   // Commit the pending load of unrelated site.
   content::WebContentsTester::For(web_contents())->CommitPendingNavigation();
   {
     // The unrelated site is not on the whitelist, even if the same subresource
     // was on it.
-    SafeBrowsingUIManager::UnsafeResource resource =
+    security_interstitials::UnsafeResource resource =
         MakeUnsafeResource(kBadURL, true /* is_subresource */);
     EXPECT_FALSE(IsWhitelisted(resource));
   }
 
   // Navigate back to the original landing url.
   NavigateAndCommit(GURL(kLandingURL));
   {
-    SafeBrowsingUIManager::UnsafeResource resource =
+    security_interstitials::UnsafeResource resource =
         MakeUnsafeResource(kBadURL, true /* is_subresource */);
     // Original resource url is whitelisted.
     EXPECT_TRUE(IsWhitelisted(resource));
   }
   {
     // A different malware subresource on the same page is also whitelisted.
     // (The whitelist is by the page url, not the resource url.)
-    SafeBrowsingUIManager::UnsafeResource resource2 =
+    security_interstitials::UnsafeResource resource2 =
         MakeUnsafeResource(kAnotherBadURL, true /* is_subresource */);
     EXPECT_TRUE(IsWhitelisted(resource2));
   }
 }
 
 TEST_F(SafeBrowsingUIManagerTest, UICallbackProceed) {
-  SafeBrowsingUIManager::UnsafeResource resource =
+  security_interstitials::UnsafeResource resource =
       MakeUnsafeResourceAndStartNavigation(kBadURL);
   SafeBrowsingCallbackWaiter waiter;
   resource.callback =
       base::Bind(&SafeBrowsingCallbackWaiter::OnBlockingPageDone,
                  base::Unretained(&waiter));
   resource.callback_thread =
       BrowserThread::GetTaskRunnerForThread(BrowserThread::UI);
-  std::vector<SafeBrowsingUIManager::UnsafeResource> resources;
+  std::vector<security_interstitials::UnsafeResource> resources;
   resources.push_back(resource);
   SimulateBlockingPageDone(resources, true);
   EXPECT_TRUE(IsWhitelisted(resource));
   waiter.WaitForCallback();
   EXPECT_TRUE(waiter.callback_called());
   EXPECT_TRUE(waiter.proceed());
 }
 
 TEST_F(SafeBrowsingUIManagerTest, UICallbackDontProceed) {
-  SafeBrowsingUIManager::UnsafeResource resource =
+  security_interstitials::UnsafeResource resource =
       MakeUnsafeResourceAndStartNavigation(kBadURL);
   SafeBrowsingCallbackWaiter waiter;
   resource.callback =
       base::Bind(&SafeBrowsingCallbackWaiter::OnBlockingPageDone,
                  base::Unretained(&waiter));
   resource.callback_thread =
       BrowserThread::GetTaskRunnerForThread(BrowserThread::UI);
-  std::vector<SafeBrowsingUIManager::UnsafeResource> resources;
+  std::vector<security_interstitials::UnsafeResource> resources;
   resources.push_back(resource);
   SimulateBlockingPageDone(resources, false);
   EXPECT_FALSE(IsWhitelisted(resource));
   waiter.WaitForCallback();
   EXPECT_TRUE(waiter.callback_called());
   EXPECT_FALSE(waiter.proceed());
 }
 
 TEST_F(SafeBrowsingUIManagerTest, IOCallbackProceed) {
-  SafeBrowsingUIManager::UnsafeResource resource =
+  security_interstitials::UnsafeResource resource =
       MakeUnsafeResourceAndStartNavigation(kBadURL);
   SafeBrowsingCallbackWaiter waiter;
   resource.callback =
       base::Bind(&SafeBrowsingCallbackWaiter::OnBlockingPageDoneOnIO,
                  base::Unretained(&waiter));
   resource.callback_thread =
       BrowserThread::GetTaskRunnerForThread(BrowserThread::IO);
-  std::vector<SafeBrowsingUIManager::UnsafeResource> resources;
+  std::vector<security_interstitials::UnsafeResource> resources;
   resources.push_back(resource);
   SimulateBlockingPageDone(resources, true);
   EXPECT_TRUE(IsWhitelisted(resource));
   waiter.WaitForCallback();
   EXPECT_TRUE(waiter.callback_called());
   EXPECT_TRUE(waiter.proceed());
 }
 
 TEST_F(SafeBrowsingUIManagerTest, IOCallbackDontProceed) {
-  SafeBrowsingUIManager::UnsafeResource resource =
+  security_interstitials::UnsafeResource resource =
       MakeUnsafeResourceAndStartNavigation(kBadURL);
   SafeBrowsingCallbackWaiter waiter;
   resource.callback =
       base::Bind(&SafeBrowsingCallbackWaiter::OnBlockingPageDoneOnIO,
                  base::Unretained(&waiter));
   resource.callback_thread =
       BrowserThread::GetTaskRunnerForThread(BrowserThread::IO);
-  std::vector<SafeBrowsingUIManager::UnsafeResource> resources;
+  std::vector<security_interstitials::UnsafeResource> resources;
   resources.push_back(resource);
   SimulateBlockingPageDone(resources, false);
   EXPECT_FALSE(IsWhitelisted(resource));
   waiter.WaitForCallback();
   EXPECT_TRUE(waiter.callback_called());
   EXPECT_FALSE(waiter.proceed());
 }
 
 namespace {
 
@@ skipping 62 matching lines @@
 // Tests that the WebContentsDelegate is notified of a visible security
 // state change when a blocking page is shown for a subresource.
 TEST_F(SafeBrowsingUIManagerTest,
        VisibleSecurityStateChangedForUnsafeSubresource) {
   TestSafeBrowsingBlockingPageFactory factory;
   SafeBrowsingBlockingPage::RegisterFactory(&factory);
   SecurityStateWebContentsDelegate delegate;
   web_contents()->SetDelegate(&delegate);
 
   // Simulate a blocking page showing for an unsafe subresource.
-  SafeBrowsingUIManager::UnsafeResource resource =
+  security_interstitials::UnsafeResource resource =
       MakeUnsafeResource(kBadURL, true /* is_subresource */);
   // Needed for showing the blocking page.
   resource.threat_source = safe_browsing::ThreatSource::REMOTE;
   NavigateAndCommit(GURL("http://example.test"));
 
   delegate.ClearVisibleSecurityStateChanged();
   EXPECT_FALSE(delegate.visible_security_state_changed());
   ui_manager()->DisplayBlockingPage(resource);
   EXPECT_TRUE(delegate.visible_security_state_changed());
 
   // Simulate proceeding through the blocking page.
   SafeBrowsingCallbackWaiter waiter;
   resource.callback =
       base::Bind(&SafeBrowsingCallbackWaiter::OnBlockingPageDoneOnIO,
                  base::Unretained(&waiter));
   resource.callback_thread =
       BrowserThread::GetTaskRunnerForThread(BrowserThread::IO);
-  std::vector<SafeBrowsingUIManager::UnsafeResource> resources;
+  std::vector<security_interstitials::UnsafeResource> resources;
   resources.push_back(resource);
 
   delegate.ClearVisibleSecurityStateChanged();
   EXPECT_FALSE(delegate.visible_security_state_changed());
   SimulateBlockingPageDone(resources, true);
   EXPECT_TRUE(delegate.visible_security_state_changed());
 
   waiter.WaitForCallback();
   EXPECT_TRUE(waiter.callback_called());
   EXPECT_TRUE(waiter.proceed());
   EXPECT_TRUE(IsWhitelisted(resource));
 }
 
 }  // namespace safe_browsing