Move code in components/safe_browsing_db and chrome/browser/s_b/ under the safe_browsing namespace.

chrome/browser/prerender/prerender_browsertest.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.
 
 #include <deque>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/files/file_path.h"
@@ skipping 108 matching lines @@
 using content::NavigationController;
 using content::OpenURLParams;
 using content::Referrer;
 using content::RenderFrameHost;
 using content::RenderViewHost;
 using content::RenderWidgetHost;
 using content::TestNavigationObserver;
 using content::WebContents;
 using content::WebContentsObserver;
 using net::NetworkChangeNotifier;
+using safe_browsing::LocalSafeBrowsingDatabaseManager;
+using safe_browsing::SafeBrowsingService;
+using safe_browsing::SBThreatType;
 using task_manager::browsertest_util::WaitForTaskManagerRows;
 
 // Prerender tests work as follows:
 //
 // A page with a prefetch link to the test page is loaded.  Once prerendered,
 // its Javascript function DidPrerenderPass() is called, which returns true if
 // the page behaves as expected when prerendered.
 //
 // The prerendered page is then displayed on a tab.  The Javascript function
 // DidDisplayPass() is called, and returns true if the page behaved as it
@@ skipping 572 matching lines @@
 // because FakeSafeBrowsingDatabaseManager does not implement
 // LocalSafeBrowsingDatabaseManager.
 #if defined(FULL_SAFE_BROWSING)
 // A SafeBrowsingDatabaseManager implementation that returns a fixed result for
 // a given URL.
 class FakeSafeBrowsingDatabaseManager
     : public LocalSafeBrowsingDatabaseManager {
  public:
   explicit FakeSafeBrowsingDatabaseManager(SafeBrowsingService* service)
       : LocalSafeBrowsingDatabaseManager(service),
-        threat_type_(SB_THREAT_TYPE_SAFE) {}
+        threat_type_(safe_browsing::SB_THREAT_TYPE_SAFE) {}
 
   // Called on the IO thread to check if the given url is safe or not.  If we
   // can synchronously determine that the url is safe, CheckUrl returns true.
   // Otherwise it returns false, and "client" is called asynchronously with the
   // result when it is ready.
   // Returns true, indicating a SAFE result, unless the URL is the fixed URL
   // specified by the user, and the user-specified result is not SAFE
   // (in which that result will be communicated back via a call into the
   // client, and false will be returned).
   // Overrides SafeBrowsingDatabaseManager::CheckBrowseUrl.
   bool CheckBrowseUrl(const GURL& gurl, Client* client) override {
-    if (gurl != url_ || threat_type_ == SB_THREAT_TYPE_SAFE)
+    if (gurl != url_ || threat_type_ == safe_browsing::SB_THREAT_TYPE_SAFE)
       return true;
 
     BrowserThread::PostTask(
         BrowserThread::IO, FROM_HERE,
         base::Bind(&FakeSafeBrowsingDatabaseManager::OnCheckBrowseURLDone,
                    this, gurl, client));
     return false;
   }
 
   void SetThreatTypeForUrl(const GURL& url, SBThreatType threat_type) {
     url_ = url;
     threat_type_ = threat_type;
   }
 
  private:
   ~FakeSafeBrowsingDatabaseManager() override {}
 
   void OnCheckBrowseURLDone(const GURL& gurl, Client* client) {
     std::vector<SBThreatType> expected_threats;
-    expected_threats.push_back(SB_THREAT_TYPE_URL_MALWARE);
-    expected_threats.push_back(SB_THREAT_TYPE_URL_PHISHING);
+    expected_threats.push_back(safe_browsing::SB_THREAT_TYPE_URL_MALWARE);
+    expected_threats.push_back(safe_browsing::SB_THREAT_TYPE_URL_PHISHING);
     // TODO(nparker): Replace SafeBrowsingCheck w/ a call to
     // client->OnCheckBrowseUrlResult()
     LocalSafeBrowsingDatabaseManager::SafeBrowsingCheck sb_check(
         std::vector<GURL>(1, gurl),
-        std::vector<SBFullHash>(),
+        std::vector<safe_browsing::SBFullHash>(),
         client,
         safe_browsing::MALWARE,
         expected_threats);
     sb_check.url_results[0] = threat_type_;
     sb_check.OnSafeBrowsingResult();
   }
 
   GURL url_;
   SBThreatType threat_type_;
   DISALLOW_COPY_AND_ASSIGN(FakeSafeBrowsingDatabaseManager);
 };
 
 class FakeSafeBrowsingService : public SafeBrowsingService {
  public:
   FakeSafeBrowsingService() { }
 
   // Returned pointer has the same lifespan as the database_manager_ refcounted
   // object.
   FakeSafeBrowsingDatabaseManager* fake_database_manager() {
     return fake_database_manager_;
   }
 
  protected:
   ~FakeSafeBrowsingService() override {}
 
-  SafeBrowsingDatabaseManager* CreateDatabaseManager() override {
+  safe_browsing::SafeBrowsingDatabaseManager* CreateDatabaseManager() override {
     fake_database_manager_ = new FakeSafeBrowsingDatabaseManager(this);
     return fake_database_manager_;
   }
 
  private:
   FakeSafeBrowsingDatabaseManager* fake_database_manager_;
 
   DISALLOW_COPY_AND_ASSIGN(FakeSafeBrowsingService);
 };
 
 // Factory that creates FakeSafeBrowsingService instances.
-class TestSafeBrowsingServiceFactory : public SafeBrowsingServiceFactory {
+class TestSafeBrowsingServiceFactory
+    : public safe_browsing::SafeBrowsingServiceFactory {
  public:
   TestSafeBrowsingServiceFactory() :
       most_recent_service_(NULL) { }
   ~TestSafeBrowsingServiceFactory() override {}
 
   SafeBrowsingService* CreateSafeBrowsingService() override {
     most_recent_service_ =  new FakeSafeBrowsingService();
     return most_recent_service_;
   }
 
@@ skipping 2233 matching lines @@
                    FINAL_STATUS_SSL_CLIENT_CERTIFICATE_REQUESTED,
                    0);
 }
 
 #if defined(FULL_SAFE_BROWSING)
 // Ensures that we do not prerender pages with a safe browsing
 // interstitial.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderSafeBrowsingTopLevel) {
   GURL url = test_server()->GetURL("files/prerender/prerender_page.html");
   GetFakeSafeBrowsingDatabaseManager()->SetThreatTypeForUrl(
-      url, SB_THREAT_TYPE_URL_MALWARE);
+      url, safe_browsing::SB_THREAT_TYPE_URL_MALWARE);
   PrerenderTestURL("files/prerender/prerender_page.html",
                    FINAL_STATUS_SAFE_BROWSING, 0);
 }
 
 // Ensures that server redirects to a malware page will cancel prerenders.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest,
                        PrerenderSafeBrowsingServerRedirect) {
   GURL url = test_server()->GetURL("files/prerender/prerender_page.html");
   GetFakeSafeBrowsingDatabaseManager()->SetThreatTypeForUrl(
-      url, SB_THREAT_TYPE_URL_MALWARE);
+      url, safe_browsing::SB_THREAT_TYPE_URL_MALWARE);
   PrerenderTestURL(CreateServerRedirect("files/prerender/prerender_page.html"),
                    FINAL_STATUS_SAFE_BROWSING,
                    0);
 }
 
 // Ensures that client redirects to a malware page will cancel prerenders.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest,
                        PrerenderSafeBrowsingClientRedirect) {
   GURL url = test_server()->GetURL("files/prerender/prerender_page.html");
   GetFakeSafeBrowsingDatabaseManager()->SetThreatTypeForUrl(
-      url, SB_THREAT_TYPE_URL_MALWARE);
+      url, safe_browsing::SB_THREAT_TYPE_URL_MALWARE);
   PrerenderTestURL(CreateClientRedirect("files/prerender/prerender_page.html"),
                    FINAL_STATUS_SAFE_BROWSING,
                    1);
 }
 
 // Ensures that we do not prerender pages which have a malware subresource.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderSafeBrowsingSubresource) {
   GURL image_url = test_server()->GetURL("files/prerender/image.jpeg");
   GetFakeSafeBrowsingDatabaseManager()->SetThreatTypeForUrl(
-      image_url, SB_THREAT_TYPE_URL_MALWARE);
+      image_url, safe_browsing::SB_THREAT_TYPE_URL_MALWARE);
   std::vector<net::SpawnedTestServer::StringPair> replacement_text;
   replacement_text.push_back(
       std::make_pair("REPLACE_WITH_IMAGE_URL", image_url.spec()));
   std::string replacement_path;
   ASSERT_TRUE(net::SpawnedTestServer::GetFilePathWithReplacements(
       "files/prerender/prerender_with_image.html",
       replacement_text,
       &replacement_path));
   PrerenderTestURL(replacement_path,
                    FINAL_STATUS_SAFE_BROWSING,
                    0);
 }
 
 // Ensures that we do not prerender pages which have a malware iframe.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderSafeBrowsingIframe) {
   GURL iframe_url = test_server()->GetURL(
       "files/prerender/prerender_embedded_content.html");
   GetFakeSafeBrowsingDatabaseManager()->SetThreatTypeForUrl(
-      iframe_url, SB_THREAT_TYPE_URL_MALWARE);
+      iframe_url, safe_browsing::SB_THREAT_TYPE_URL_MALWARE);
   std::vector<net::SpawnedTestServer::StringPair> replacement_text;
   replacement_text.push_back(
       std::make_pair("REPLACE_WITH_URL", iframe_url.spec()));
   std::string replacement_path;
   ASSERT_TRUE(net::SpawnedTestServer::GetFilePathWithReplacements(
       "files/prerender/prerender_with_iframe.html",
       replacement_text,
       &replacement_path));
   PrerenderTestURL(replacement_path,
                    FINAL_STATUS_SAFE_BROWSING,
@@ skipping 1051 matching lines @@
 
   NavigateToDestURL();
   EXPECT_EQ(1U, task_manager.tasks().size());
 }
 
 }  // namespace
 
 #endif  // defined(ENABLE_TASK_MANAGER)
 
 }  // namespace prerender