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

chrome/browser/safe_browsing/safe_browsing_service_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.
 //
 // This test creates a safebrowsing service using test safebrowsing database
 // and a test protocol manager. It is used to test logics in safebrowsing
 // service.
 
 #include <algorithm>
 
@@ skipping 52 matching lines @@
 #error This test requires SAFE_BROWSING_DB_LOCAL.
 #endif
 
 using content::BrowserThread;
 using content::InterstitialPage;
 using content::WebContents;
 using ::testing::_;
 using ::testing::Mock;
 using ::testing::StrictMock;
 
+namespace safe_browsing {
+
 namespace {
 
 void InvokeFullHashCallback(
     SafeBrowsingProtocolManager::FullHashCallback callback,
     const std::vector<SBFullHashResult>& result) {
   callback.Run(result, base::TimeDelta::FromMinutes(45));
 }
 
 class FakeSafeBrowsingService : public SafeBrowsingService {
  public:
@@ skipping 26 matching lines @@
 
   SafeBrowsingService* CreateSafeBrowsingService() override {
     return new FakeSafeBrowsingService(url_prefix_);
   }
 
  private:
   std::string url_prefix_;
 };
 
 // A SafeBrowingDatabase class that allows us to inject the malicious URLs.
-class TestSafeBrowsingDatabase :  public SafeBrowsingDatabase {
+class TestSafeBrowsingDatabase : public SafeBrowsingDatabase {
  public:
   TestSafeBrowsingDatabase() {}
 
   ~TestSafeBrowsingDatabase() override {}
 
   // Initializes the database with the given filename.
   void Init(const base::FilePath& filename) override {}
 
   // Deletes the current database and creates a new one.
   bool ResetDatabase() override {
     badurls_.clear();
     return true;
   }
 
   // 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.
   bool ContainsBrowseUrl(const GURL& url,
                          std::vector<SBPrefix>* prefix_hits,
                          std::vector<SBFullHashResult>* cache_hits) override {
     cache_hits->clear();
-    return ContainsUrl(safe_browsing::MALWARE,
-                       safe_browsing::PHISH,
-                       std::vector<GURL>(1, url),
-                       prefix_hits);
+    return ContainsUrl(MALWARE, PHISH, std::vector<GURL>(1, url), prefix_hits);
   }
   bool ContainsUnwantedSoftwareUrl(
       const GURL& url,
       std::vector<SBPrefix>* prefix_hits,
       std::vector<SBFullHashResult>* cache_hits) override {
     cache_hits->clear();
-    return ContainsUrl(safe_browsing::UNWANTEDURL,
-                       safe_browsing::UNWANTEDURL,
-                       std::vector<GURL>(1, url),
+    return ContainsUrl(UNWANTEDURL, UNWANTEDURL, std::vector<GURL>(1, url),
                        prefix_hits);
   }
   bool ContainsDownloadUrlPrefixes(
       const std::vector<SBPrefix>& prefixes,
       std::vector<SBPrefix>* prefix_hits) override {
-    bool found =
-        ContainsUrlPrefixes(safe_browsing::BINURL,
-                            safe_browsing::BINURL, prefixes, prefix_hits);
+    bool found = ContainsUrlPrefixes(BINURL, BINURL, prefixes, prefix_hits);
     if (!found)
       return false;
     DCHECK_LE(1U, prefix_hits->size());
     return true;
   }
   bool ContainsCsdWhitelistedUrl(const GURL& url) override { return true; }
   bool ContainsDownloadWhitelistedString(const std::string& str) override {
     return true;
   }
   bool ContainsDownloadWhitelistedUrl(const GURL& url) override { return true; }
@@ skipping 29 matching lines @@
   bool IsMalwareIPMatchKillSwitchOn() override { return false; }
   bool IsCsdWhitelistKillSwitchOn() override { return false; }
 
   // Fill up the database with test URL.
   void AddUrl(const GURL& url,
               const SBFullHashResult& full_hash,
               const std::vector<SBPrefix>& prefix_hits) {
     Hits* hits_for_url = &badurls_[url.spec()];
     hits_for_url->list_ids.push_back(full_hash.list_id);
     hits_for_url->prefix_hits.insert(hits_for_url->prefix_hits.end(),
-                                     prefix_hits.begin(),
-                                     prefix_hits.end());
+                                     prefix_hits.begin(), prefix_hits.end());
     bad_prefixes_.insert(
         std::make_pair(full_hash.list_id, full_hash.hash.prefix));
   }
 
  private:
   // Stores |list_ids| of safe browsing lists that match some |prefix_hits|.
   struct Hits {
     std::vector<int> list_ids;
     std::vector<SBPrefix> prefix_hits;
   };
 
   bool ContainsUrl(int list_id0,
                    int list_id1,
                    const std::vector<GURL>& urls,
                    std::vector<SBPrefix>* prefix_hits) {
     bool hit = false;
     for (const GURL& url : urls) {
-      base::hash_map<std::string, Hits>::const_iterator
-          badurls_it = badurls_.find(url.spec());
+      base::hash_map<std::string, Hits>::const_iterator badurls_it =
+          badurls_.find(url.spec());
 
       if (badurls_it == badurls_.end())
         continue;
 
       std::vector<int> list_ids_for_url = badurls_it->second.list_ids;
       if (std::find(list_ids_for_url.begin(), list_ids_for_url.end(), list_id0)
               != list_ids_for_url.end() ||
           std::find(list_ids_for_url.begin(), list_ids_for_url.end(), list_id1)
               != list_ids_for_url.end()) {
         prefix_hits->insert(prefix_hits->end(),
@@ skipping 38 matching lines @@
       const scoped_refptr<base::SequencedTaskRunner>& db_task_runner,
       bool enable_download_protection,
       bool enable_client_side_whitelist,
       bool enable_download_whitelist,
       bool enable_extension_blacklist,
       bool enable_ip_blacklist,
       bool enabled_unwanted_software_list) override {
     db_ = new TestSafeBrowsingDatabase();
     return db_;
   }
-  TestSafeBrowsingDatabase* GetDb() {
-    return db_;
-  }
+  TestSafeBrowsingDatabase* GetDb() { return db_; }
+
  private:
   // Owned by the SafebrowsingService.
   TestSafeBrowsingDatabase* db_;
 };
 
 // A TestProtocolManager that could return fixed responses from
 // safebrowsing server for testing purpose.
-class TestProtocolManager :  public SafeBrowsingProtocolManager {
+class TestProtocolManager : public SafeBrowsingProtocolManager {
  public:
   TestProtocolManager(SafeBrowsingProtocolManagerDelegate* delegate,
                       net::URLRequestContextGetter* request_context_getter,
                       const SafeBrowsingProtocolConfig& config)
       : SafeBrowsingProtocolManager(delegate, request_context_getter, config) {
     create_count_++;
   }
 
   ~TestProtocolManager() override { delete_count_++; }
 
   // This function is called when there is a prefix hit in local safebrowsing
   // database and safebrowsing service issues a get hash request to backends.
   // We return a result from the prefilled full_hashes_ hash_map to simulate
   // server's response. At the same time, latency is added to simulate real
   // life network issues.
   void GetFullHash(const std::vector<SBPrefix>& prefixes,
                    SafeBrowsingProtocolManager::FullHashCallback callback,
                    bool is_download,
                    bool is_extended_reporting) override {
     BrowserThread::PostDelayedTask(
         BrowserThread::IO, FROM_HERE,
-        base::Bind(InvokeFullHashCallback, callback, full_hashes_),
-        delay_);
+        base::Bind(InvokeFullHashCallback, callback, full_hashes_), delay_);
   }
 
   // Prepare the GetFullHash results for the next request.
   void AddGetFullHashResponse(const SBFullHashResult& full_hash_result) {
     full_hashes_.push_back(full_hash_result);
   }
 
-  void IntroduceDelay(const base::TimeDelta& delay) {
-    delay_ = delay;
-  }
+  void IntroduceDelay(const base::TimeDelta& delay) { delay_ = delay; }
 
-  static int create_count() {
-    return create_count_;
-  }
+  static int create_count() { return create_count_; }
 
-  static int delete_count() {
-    return delete_count_;
-  }
+  static int delete_count() { return delete_count_; }
 
  private:
   std::vector<SBFullHashResult> full_hashes_;
   base::TimeDelta delay_;
   static int create_count_;
   static int delete_count_;
 };
 
 // static
 int TestProtocolManager::create_count_ = 0;
 // static
 int TestProtocolManager::delete_count_ = 0;
 
 // Factory that creates TestProtocolManager instances.
 class TestSBProtocolManagerFactory : public SBProtocolManagerFactory {
  public:
   TestSBProtocolManagerFactory() : pm_(NULL) {}
   ~TestSBProtocolManagerFactory() override {}
 
   SafeBrowsingProtocolManager* CreateProtocolManager(
       SafeBrowsingProtocolManagerDelegate* delegate,
       net::URLRequestContextGetter* request_context_getter,
       const SafeBrowsingProtocolConfig& config) override {
     pm_ = new TestProtocolManager(delegate, request_context_getter, config);
     return pm_;
   }
 
-  TestProtocolManager* GetProtocolManager() {
-    return pm_;
-  }
+  TestProtocolManager* GetProtocolManager() { return pm_; }
 
  private:
   // Owned by the SafebrowsingService.
   TestProtocolManager* pm_;
 };
 
 class MockObserver : public SafeBrowsingUIManager::Observer {
  public:
   MockObserver() {}
   virtual ~MockObserver() {}
@@ skipping 27 matching lines @@
 
   scoped_refptr<SafeBrowsingService> service_;
   const bool expected_enabled_;
 };
 
 }  // namespace
 
 // Tests the safe browsing blocking page in a browser.
 class SafeBrowsingServiceTest : public InProcessBrowserTest {
  public:
-  SafeBrowsingServiceTest() {
-  }
+  SafeBrowsingServiceTest() {}
 
   static void GenUrlFullhashResult(const GURL& url,
                                    int list_id,
                                    SBFullHashResult* full_hash) {
     std::string host;
     std::string path;
-    safe_browsing::CanonicalizeUrl(url, &host, &path, NULL);
-    full_hash->hash = safe_browsing::SBFullHashForString(host + path);
+    CanonicalizeUrl(url, &host, &path, NULL);
+    full_hash->hash = SBFullHashForString(host + path);
     full_hash->list_id = list_id;
   }
 
   void SetUp() override {
     // InProcessBrowserTest::SetUp() instantiates SafebrowsingService and
     // RegisterFactory has to be called before SafeBrowsingService is created.
     sb_factory_.reset(new TestSafeBrowsingServiceFactory(
         "https://definatelynotarealdomain/safebrowsing"));
     SafeBrowsingService::RegisterFactory(sb_factory_.get());
     SafeBrowsingDatabase::RegisterFactory(&db_factory_);
@@ skipping 81 matching lines @@
     return LocalDatabaseManagerForService(sb_service)->check_timeout_;
   }
 
   static void SetCheckTimeout(SafeBrowsingService* sb_service,
                               const base::TimeDelta& delay) {
     LocalDatabaseManagerForService(sb_service)->check_timeout_ = delay;
   }
 
   void CreateCSDService() {
 #if defined(SAFE_BROWSING_CSD)
-    safe_browsing::ClientSideDetectionService* csd_service =
-        safe_browsing::ClientSideDetectionService::Create(NULL);
+    ClientSideDetectionService* csd_service =
+        ClientSideDetectionService::Create(NULL);
     SafeBrowsingService* sb_service =
         g_browser_process->safe_browsing_service();
 
     // A CSD service should already exist.
     EXPECT_TRUE(sb_service->csd_service_);
 
     sb_service->csd_service_.reset(csd_service);
     sb_service->RefreshState();
 #endif
   }
@@ skipping 52 matching lines @@
 };
 
 class SafeBrowsingServiceMetadataTest
     : public SafeBrowsingServiceTest,
       public ::testing::WithParamInterface<MalwareMetadataTestType> {
  public:
   SafeBrowsingServiceMetadataTest() {}
 
   void GenUrlFullhashResultWithMetadata(const GURL& url,
                                         SBFullHashResult* full_hash) {
-    GenUrlFullhashResult(url, safe_browsing::MALWARE, full_hash);
+    GenUrlFullhashResult(url, MALWARE, full_hash);
 
-    safe_browsing::MalwarePatternType proto;
+    MalwarePatternType proto;
     switch (GetParam()) {
       case METADATA_NONE:
         full_hash->metadata = std::string();
         break;
       case METADATA_LANDING:
-        proto.set_pattern_type(safe_browsing::MalwarePatternType::LANDING);
+        proto.set_pattern_type(MalwarePatternType::LANDING);
         full_hash->metadata = proto.SerializeAsString();
         break;
       case METADATA_DISTRIBUTION:
-        proto.set_pattern_type(safe_browsing::MalwarePatternType::DISTRIBUTION);
+        proto.set_pattern_type(MalwarePatternType::DISTRIBUTION);
         full_hash->metadata = proto.SerializeAsString();
         break;
     }
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(SafeBrowsingServiceMetadataTest);
 };
 
 namespace {
@@ skipping 21 matching lines @@
   EXPECT_TRUE(ShowingInterstitialPage());
 }
 
 IN_PROC_BROWSER_TEST_P(SafeBrowsingServiceMetadataTest, MalwareIFrame) {
   GURL main_url = embedded_test_server()->GetURL(kMalwarePage);
   GURL iframe_url = embedded_test_server()->GetURL(kMalwareIFrame);
 
   // Add the iframe url as malware and then load the parent page.
   SBFullHashResult malware_full_hash;
   GenUrlFullhashResultWithMetadata(iframe_url, &malware_full_hash);
-  EXPECT_CALL(observer_, OnSafeBrowsingMatch(IsUnsafeResourceFor(iframe_url)))
-      .Times(1);
-  EXPECT_CALL(observer_, OnSafeBrowsingHit(IsUnsafeResourceFor(iframe_url)))
-      .Times(1);
+  EXPECT_CALL(observer_,
+              OnSafeBrowsingMatch(IsUnsafeResourceFor(iframe_url))).Times(1);
+  EXPECT_CALL(observer_,
+              OnSafeBrowsingHit(IsUnsafeResourceFor(iframe_url))).Times(1);
   SetupResponseForUrl(iframe_url, malware_full_hash);
   ui_test_utils::NavigateToURL(browser(), main_url);
   // All types should show the interstitial.
   EXPECT_TRUE(ShowingInterstitialPage());
 }
 
 IN_PROC_BROWSER_TEST_P(SafeBrowsingServiceMetadataTest, MalwareImg) {
   GURL main_url = embedded_test_server()->GetURL(kMalwarePage);
   GURL img_url = embedded_test_server()->GetURL(kMalwareImg);
 
@@ skipping 33 matching lines @@
                                         METADATA_LANDING,
                                         METADATA_DISTRIBUTION));
 
 IN_PROC_BROWSER_TEST_F(SafeBrowsingServiceTest, UnwantedImgIgnored) {
   GURL main_url = embedded_test_server()->GetURL(kMalwarePage);
   GURL img_url = embedded_test_server()->GetURL(kMalwareImg);
 
   // Add the img url as coming from a site serving UwS and then load the parent
   // page.
   SBFullHashResult uws_full_hash;
-  GenUrlFullhashResult(img_url, safe_browsing::UNWANTEDURL,
-                       &uws_full_hash);
+  GenUrlFullhashResult(img_url, UNWANTEDURL, &uws_full_hash);
   SetupResponseForUrl(img_url, uws_full_hash);
 
   ui_test_utils::NavigateToURL(browser(), main_url);
 
   EXPECT_FALSE(ShowingInterstitialPage());
 }
 
 IN_PROC_BROWSER_TEST_F(SafeBrowsingServiceTest, DISABLED_MalwareWithWhitelist) {
   GURL url = embedded_test_server()->GetURL(kEmptyPage);
 
   // After adding the url to safebrowsing database and getfullhash result,
   // we should see the interstitial page.
   SBFullHashResult malware_full_hash;
-  GenUrlFullhashResult(url, safe_browsing::MALWARE, &malware_full_hash);
+  GenUrlFullhashResult(url, MALWARE, &malware_full_hash);
   EXPECT_CALL(observer_,
               OnSafeBrowsingMatch(IsUnsafeResourceFor(url))).Times(1);
-  EXPECT_CALL(observer_, OnSafeBrowsingHit(IsUnsafeResourceFor(url))).Times(1)
+  EXPECT_CALL(observer_, OnSafeBrowsingHit(IsUnsafeResourceFor(url)))
+      .Times(1)
       .WillOnce(testing::Invoke(
           this, &SafeBrowsingServiceTest::ProceedAndWhitelist));
   SetupResponseForUrl(url, malware_full_hash);
 
   ui_test_utils::NavigateToURL(browser(), url);
   // Mock calls OnBlockingPageDone set to proceed, so the interstitial
   // is removed.
   EXPECT_FALSE(ShowingInterstitialPage());
   Mock::VerifyAndClearExpectations(&observer_);
 
@@ skipping 30 matching lines @@
     }
 
    private:
     prerender::PrerenderManager::PrerenderManagerMode old_prerender_mode_;
   } set_prefetch_for_test(true);
 
   // Even though we have added this uri to the safebrowsing database and
   // getfullhash result, we should not see the interstitial page since the
   // only malware was a prefetch target.
   SBFullHashResult malware_full_hash;
-  GenUrlFullhashResult(malware_url, safe_browsing::MALWARE,
-                       &malware_full_hash);
+  GenUrlFullhashResult(malware_url, MALWARE, &malware_full_hash);
   SetupResponseForUrl(malware_url, malware_full_hash);
   ui_test_utils::NavigateToURL(browser(), url);
   EXPECT_FALSE(ShowingInterstitialPage());
   Mock::VerifyAndClear(&observer_);
 
   // However, when we navigate to the malware page, we should still get
   // the interstitial.
   EXPECT_CALL(observer_, OnSafeBrowsingMatch(IsUnsafeResourceFor(malware_url)))
       .Times(1);
   EXPECT_CALL(observer_, OnSafeBrowsingHit(IsUnsafeResourceFor(malware_url)))
       .Times(1);
   ui_test_utils::NavigateToURL(browser(), malware_url);
   EXPECT_TRUE(ShowingInterstitialPage());
   Mock::VerifyAndClear(&observer_);
 }
 
 }  // namespace
 
-class TestSBClient
-    : public base::RefCountedThreadSafe<TestSBClient>,
-      public SafeBrowsingDatabaseManager::Client {
+class TestSBClient : public base::RefCountedThreadSafe<TestSBClient>,
+                     public SafeBrowsingDatabaseManager::Client {
  public:
   TestSBClient()
-    : threat_type_(SB_THREAT_TYPE_SAFE),
-      safe_browsing_service_(g_browser_process->safe_browsing_service()) {
-  }
+      : threat_type_(SB_THREAT_TYPE_SAFE),
+        safe_browsing_service_(g_browser_process->safe_browsing_service()) {}
 
-  SBThreatType GetThreatType() const {
-    return threat_type_;
-  }
+  SBThreatType GetThreatType() const { return threat_type_; }
 
   void CheckDownloadUrl(const std::vector<GURL>& url_chain) {
     BrowserThread::PostTask(
         BrowserThread::IO, FROM_HERE,
-        base::Bind(&TestSBClient::CheckDownloadUrlOnIOThread,
-                   this, url_chain));
+        base::Bind(&TestSBClient::CheckDownloadUrlOnIOThread, this, url_chain));
     content::RunMessageLoop();  // Will stop in OnCheckDownloadUrlResult.
   }
 
   void CheckBrowseUrl(const GURL& url) {
     BrowserThread::PostTask(
         BrowserThread::IO, FROM_HERE,
         base::Bind(&TestSBClient::CheckBrowseUrlOnIOThread, this, url));
     content::RunMessageLoop();  // Will stop in OnCheckBrowseUrlResult.
   }
 
@@ skipping 57 matching lines @@
   GURL badbin_url = embedded_test_server()->GetURL(kMalwareFile);
   std::vector<GURL> badbin_urls(1, badbin_url);
 
   scoped_refptr<TestSBClient> client(new TestSBClient);
   client->CheckDownloadUrl(badbin_urls);
 
   // Since badbin_url is not in database, it is considered to be safe.
   EXPECT_EQ(SB_THREAT_TYPE_SAFE, client->GetThreatType());
 
   SBFullHashResult full_hash_result;
-  GenUrlFullhashResult(badbin_url, safe_browsing::BINURL,
-                       &full_hash_result);
+  GenUrlFullhashResult(badbin_url, BINURL, &full_hash_result);
   SetupResponseForUrl(badbin_url, full_hash_result);
 
   client->CheckDownloadUrl(badbin_urls);
 
   // Now, the badbin_url is not safe since it is added to download database.
   EXPECT_EQ(SB_THREAT_TYPE_BINARY_MALWARE_URL, client->GetThreatType());
 }
 
 IN_PROC_BROWSER_TEST_F(SafeBrowsingServiceTest, CheckUnwantedSoftwareUrl) {
   const GURL bad_url = embedded_test_server()->GetURL(kMalwareFile);
   {
     scoped_refptr<TestSBClient> client(new TestSBClient);
 
     // Since bad_url is not in database, it is considered to be
     // safe.
     client->CheckBrowseUrl(bad_url);
     EXPECT_EQ(SB_THREAT_TYPE_SAFE, client->GetThreatType());
 
     SBFullHashResult full_hash_result;
-    GenUrlFullhashResult(
-        bad_url, safe_browsing::UNWANTEDURL, &full_hash_result);
+    GenUrlFullhashResult(bad_url, UNWANTEDURL, &full_hash_result);
     SetupResponseForUrl(bad_url, full_hash_result);
 
     // Now, the bad_url is not safe since it is added to download
     // database.
     client->CheckBrowseUrl(bad_url);
     EXPECT_EQ(SB_THREAT_TYPE_URL_UNWANTED, client->GetThreatType());
   }
 
   // The unwantedness should survive across multiple clients.
   {
     scoped_refptr<TestSBClient> client(new TestSBClient);
     client->CheckBrowseUrl(bad_url);
     EXPECT_EQ(SB_THREAT_TYPE_URL_UNWANTED, client->GetThreatType());
   }
 
   // An unwanted URL also marked as malware should be flagged as malware.
   {
     scoped_refptr<TestSBClient> client(new TestSBClient);
 
     SBFullHashResult full_hash_result;
-    GenUrlFullhashResult(
-        bad_url, safe_browsing::MALWARE, &full_hash_result);
+    GenUrlFullhashResult(bad_url, MALWARE, &full_hash_result);
     SetupResponseForUrl(bad_url, full_hash_result);
 
     client->CheckBrowseUrl(bad_url);
     EXPECT_EQ(SB_THREAT_TYPE_URL_MALWARE, client->GetThreatType());
   }
 }
 
 IN_PROC_BROWSER_TEST_F(SafeBrowsingServiceTest, CheckBrowseUrl) {
   const GURL bad_url = embedded_test_server()->GetURL(kMalwareFile);
   {
     scoped_refptr<TestSBClient> client(new TestSBClient);
 
     // Since bad_url is not in database, it is considered to be
     // safe.
     client->CheckBrowseUrl(bad_url);
     EXPECT_EQ(SB_THREAT_TYPE_SAFE, client->GetThreatType());
 
     SBFullHashResult full_hash_result;
-    GenUrlFullhashResult(
-        bad_url, safe_browsing::MALWARE, &full_hash_result);
+    GenUrlFullhashResult(bad_url, MALWARE, &full_hash_result);
     SetupResponseForUrl(bad_url, full_hash_result);
 
     // Now, the bad_url is not safe since it is added to download
     // database.
     client->CheckBrowseUrl(bad_url);
     EXPECT_EQ(SB_THREAT_TYPE_URL_MALWARE, client->GetThreatType());
   }
 
   // The unwantedness should survive across multiple clients.
   {
     scoped_refptr<TestSBClient> client(new TestSBClient);
     client->CheckBrowseUrl(bad_url);
     EXPECT_EQ(SB_THREAT_TYPE_URL_MALWARE, client->GetThreatType());
   }
 
   // Adding the unwanted state to an existing malware URL should have no impact
   // (i.e. a malware hit should still prevail).
   {
     scoped_refptr<TestSBClient> client(new TestSBClient);
 
     SBFullHashResult full_hash_result;
-    GenUrlFullhashResult(
-        bad_url, safe_browsing::UNWANTEDURL, &full_hash_result);
+    GenUrlFullhashResult(bad_url, UNWANTEDURL, &full_hash_result);
     SetupResponseForUrl(bad_url, full_hash_result);
 
     client->CheckBrowseUrl(bad_url);
     EXPECT_EQ(SB_THREAT_TYPE_URL_MALWARE, client->GetThreatType());
   }
 }
 
 IN_PROC_BROWSER_TEST_F(SafeBrowsingServiceTest, CheckDownloadUrlRedirects) {
   GURL original_url = embedded_test_server()->GetURL(kEmptyPage);
   GURL badbin_url = embedded_test_server()->GetURL(kMalwareFile);
   GURL final_url = embedded_test_server()->GetURL(kEmptyPage);
   std::vector<GURL> badbin_urls;
   badbin_urls.push_back(original_url);
   badbin_urls.push_back(badbin_url);
   badbin_urls.push_back(final_url);
 
   scoped_refptr<TestSBClient> client(new TestSBClient);
   client->CheckDownloadUrl(badbin_urls);
 
   // Since badbin_url is not in database, it is considered to be safe.
   EXPECT_EQ(SB_THREAT_TYPE_SAFE, client->GetThreatType());
 
   SBFullHashResult full_hash_result;
-  GenUrlFullhashResult(badbin_url, safe_browsing::BINURL,
-                       &full_hash_result);
+  GenUrlFullhashResult(badbin_url, BINURL, &full_hash_result);
   SetupResponseForUrl(badbin_url, full_hash_result);
 
   client->CheckDownloadUrl(badbin_urls);
 
   // Now, the badbin_url is not safe since it is added to download database.
   EXPECT_EQ(SB_THREAT_TYPE_BINARY_MALWARE_URL, client->GetThreatType());
 }
 
 #if defined(OS_WIN)
 // http://crbug.com/396409
 #define MAYBE_CheckDownloadUrlTimedOut DISABLED_CheckDownloadUrlTimedOut
 #else
 #define MAYBE_CheckDownloadUrlTimedOut CheckDownloadUrlTimedOut
 #endif
 IN_PROC_BROWSER_TEST_F(SafeBrowsingServiceTest,
                        MAYBE_CheckDownloadUrlTimedOut) {
   GURL badbin_url = embedded_test_server()->GetURL(kMalwareFile);
   std::vector<GURL> badbin_urls(1, badbin_url);
 
   scoped_refptr<TestSBClient> client(new TestSBClient);
   SBFullHashResult full_hash_result;
-  GenUrlFullhashResult(badbin_url, safe_browsing::BINURL,
-                       &full_hash_result);
+  GenUrlFullhashResult(badbin_url, BINURL, &full_hash_result);
   SetupResponseForUrl(badbin_url, full_hash_result);
   client->CheckDownloadUrl(badbin_urls);
 
   // badbin_url is not safe since it is added to download database.
   EXPECT_EQ(SB_THREAT_TYPE_BINARY_MALWARE_URL, client->GetThreatType());
 
   //
   // Now introducing delays and we should hit timeout.
   //
   SafeBrowsingService* sb_service = g_browser_process->safe_browsing_service();
   base::TimeDelta default_urlcheck_timeout = GetCheckTimeout(sb_service);
   IntroduceGetHashDelay(base::TimeDelta::FromSeconds(1));
   SetCheckTimeout(sb_service, base::TimeDelta::FromMilliseconds(1));
   client->CheckDownloadUrl(badbin_urls);
 
   // There should be a timeout and the hash would be considered as safe.
   EXPECT_EQ(SB_THREAT_TYPE_SAFE, client->GetThreatType());
 
   // Need to set the timeout back to the default value.
   SetCheckTimeout(sb_service, default_urlcheck_timeout);
 }
 
 IN_PROC_BROWSER_TEST_F(SafeBrowsingServiceTest, StartAndStop) {
   CreateCSDService();
   SafeBrowsingService* sb_service = g_browser_process->safe_browsing_service();
-  safe_browsing::ClientSideDetectionService* csd_service =
+  ClientSideDetectionService* csd_service =
       sb_service->safe_browsing_detection_service();
   PrefService* pref_service = browser()->profile()->GetPrefs();
 
   ASSERT_TRUE(sb_service != NULL);
   ASSERT_TRUE(csd_service != NULL);
   ASSERT_TRUE(pref_service != NULL);
 
   EXPECT_TRUE(pref_service->GetBoolean(prefs::kSafeBrowsingEnabled));
 
   // SBS might still be starting, make sure this doesn't flake.
   EXPECT_TRUE(sb_service->enabled_by_prefs());
   WaitForIOAndCheckEnabled(sb_service, true);
   EXPECT_TRUE(csd_service->enabled());
 
   // Add a new Profile. SBS should keep running.
   ASSERT_TRUE(temp_profile_dir_.CreateUniqueTempDir());
   scoped_ptr<Profile> profile2(Profile::CreateProfile(
       temp_profile_dir_.path(), NULL, Profile::CREATE_MODE_SYNCHRONOUS));
   ASSERT_TRUE(profile2.get() != NULL);
   StartupTaskRunnerServiceFactory::GetForProfile(profile2.get())->
-              StartDeferredTaskRunners();
+      StartDeferredTaskRunners();
   PrefService* pref_service2 = profile2->GetPrefs();
   EXPECT_TRUE(pref_service2->GetBoolean(prefs::kSafeBrowsingEnabled));
   // We don't expect the state to have changed, but if it did, wait for it.
   EXPECT_TRUE(sb_service->enabled_by_prefs());
   WaitForIOAndCheckEnabled(sb_service, true);
   EXPECT_TRUE(csd_service->enabled());
 
   // Change one of the prefs. SBS should keep running.
   pref_service->SetBoolean(prefs::kSafeBrowsingEnabled, false);
   EXPECT_TRUE(sb_service->enabled_by_prefs());
@@ skipping 57 matching lines @@
   }
 
  protected:
   Profile* profile2_;
 };
 
 IN_PROC_BROWSER_TEST_F(SafeBrowsingServiceShutdownTest,
                        DontStartAfterShutdown) {
   CreateCSDService();
   SafeBrowsingService* sb_service = g_browser_process->safe_browsing_service();
-  safe_browsing::ClientSideDetectionService* csd_service =
+  ClientSideDetectionService* csd_service =
       sb_service->safe_browsing_detection_service();
   PrefService* pref_service = browser()->profile()->GetPrefs();
 
   ASSERT_TRUE(sb_service != NULL);
   ASSERT_TRUE(csd_service != NULL);
   ASSERT_TRUE(pref_service != NULL);
 
   EXPECT_TRUE(pref_service->GetBoolean(prefs::kSafeBrowsingEnabled));
 
   // SBS might still be starting, make sure this doesn't flake.
@@ skipping 73 matching lines @@
       return false;
     }
 
     sql::Connection db;
     if (!db.Open(cookie_path)) {
       EXPECT_TRUE(false);
       return false;
     }
     // Ensure the host value in the cookie file matches the test server we will
     // be connecting to.
-    sql::Statement smt(db.GetUniqueStatement(
-        "UPDATE cookies SET host_key = ?"));
+    sql::Statement smt(
+        db.GetUniqueStatement("UPDATE cookies SET host_key = ?"));
     if (!smt.is_valid()) {
       EXPECT_TRUE(false);
       return false;
     }
     if (!smt.BindString(0, embedded_test_server()->base_url().host())) {
       EXPECT_TRUE(false);
       return false;
     }
     if (!smt.Run()) {
       EXPECT_TRUE(false);
       return false;
     }
 
     return InProcessBrowserTest::SetUpUserDataDirectory();
   }
 
   void TearDownInProcessBrowserTestFixture() override {
     InProcessBrowserTest::TearDownInProcessBrowserTestFixture();
 
     sql::Connection db;
     base::FilePath cookie_path(
         SafeBrowsingService::GetCookieFilePathForTesting());
     ASSERT_TRUE(db.Open(cookie_path));
 
-    sql::Statement smt(db.GetUniqueStatement(
-        "SELECT name, value FROM cookies ORDER BY name"));
+    sql::Statement smt(
+        db.GetUniqueStatement("SELECT name, value FROM cookies ORDER BY name"));
     ASSERT_TRUE(smt.is_valid());
 
     ASSERT_TRUE(smt.Step());
     ASSERT_EQ("a", smt.ColumnString(0));
     ASSERT_EQ("b", smt.ColumnString(1));
     ASSERT_TRUE(smt.Step());
     ASSERT_EQ("c", smt.ColumnString(0));
     ASSERT_EQ("d", smt.ColumnString(1));
     EXPECT_FALSE(smt.Step());
   }
@@ skipping 57 matching lines @@
 
 // Test that a Local Safe Browsing database update request both sends cookies
 // and can save cookies.
 IN_PROC_BROWSER_TEST_F(SafeBrowsingDatabaseManagerCookieTest,
                        TestSBUpdateCookies) {
   content::WindowedNotificationObserver observer(
       chrome::NOTIFICATION_SAFE_BROWSING_UPDATE_COMPLETE,
       content::Source<SafeBrowsingDatabaseManager>(
           sb_service_->database_manager().get()));
   BrowserThread::PostTask(
-      BrowserThread::IO,
-      FROM_HERE,
+      BrowserThread::IO, FROM_HERE,
       base::Bind(&SafeBrowsingDatabaseManagerCookieTest::ForceUpdate, this));
   observer.Wait();
 }
+
+}  // namespace safe_browsing