Move more declarations from c/b/sb/sb_util.h to components.

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 120 matching lines @@
     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_util::MALWARE,
-                       safe_browsing_util::PHISH,
+    return ContainsUrl(safe_browsing::MALWARE,
+                       safe_browsing::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_util::UNWANTEDURL,
-                       safe_browsing_util::UNWANTEDURL,
+    return ContainsUrl(safe_browsing::UNWANTEDURL,
+                       safe_browsing::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_util::BINURL,
-                            safe_browsing_util::BINURL, prefixes, prefix_hits);
+        ContainsUrlPrefixes(safe_browsing::BINURL,
+                            safe_browsing::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 245 matching lines @@
 class SafeBrowsingServiceTest : public InProcessBrowserTest {
  public:
   SafeBrowsingServiceTest() {
   }
 
   static void GenUrlFullhashResult(const GURL& url,
                                    int list_id,
                                    SBFullHashResult* full_hash) {
     std::string host;
     std::string path;
-    safe_browsing_util::CanonicalizeUrl(url, &host, &path, NULL);
-    full_hash->hash = SBFullHashForString(host + path);
+    safe_browsing::CanonicalizeUrl(url, &host, &path, NULL);
+    full_hash->hash = safe_browsing::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 155 matching lines @@
 };
 
 class SafeBrowsingServiceMetadataTest
     : public SafeBrowsingServiceTest,
       public ::testing::WithParamInterface<MalwareMetadataTestType> {
  public:
   SafeBrowsingServiceMetadataTest() {}
 
   void GenUrlFullhashResultWithMetadata(const GURL& url,
                                         SBFullHashResult* full_hash) {
-    GenUrlFullhashResult(url, safe_browsing_util::MALWARE, full_hash);
+    GenUrlFullhashResult(url, safe_browsing::MALWARE, full_hash);
 
     safe_browsing::MalwarePatternType proto;
     switch (GetParam()) {
       case METADATA_NONE:
         full_hash->metadata = std::string();
         break;
       case METADATA_LANDING:
         proto.set_pattern_type(safe_browsing::MalwarePatternType::LANDING);
         full_hash->metadata = proto.SerializeAsString();
         break;
@@ skipping 90 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_util::UNWANTEDURL,
+  GenUrlFullhashResult(img_url, safe_browsing::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_util::MALWARE, &malware_full_hash);
+  GenUrlFullhashResult(url, safe_browsing::MALWARE, &malware_full_hash);
   EXPECT_CALL(observer_,
               OnSafeBrowsingMatch(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.
@@ skipping 33 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_util::MALWARE,
+  GenUrlFullhashResult(malware_url, safe_browsing::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);
@@ skipping 94 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_util::BINURL,
+  GenUrlFullhashResult(badbin_url, safe_browsing::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_util::UNWANTEDURL, &full_hash_result);
+        bad_url, safe_browsing::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_util::MALWARE, &full_hash_result);
+        bad_url, safe_browsing::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_util::MALWARE, &full_hash_result);
+        bad_url, safe_browsing::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_util::UNWANTEDURL, &full_hash_result);
+        bad_url, safe_browsing::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_util::BINURL,
+  GenUrlFullhashResult(badbin_url, safe_browsing::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_util::BINURL,
+  GenUrlFullhashResult(badbin_url, safe_browsing::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.
   //
@@ skipping 309 matching lines @@
   content::WindowedNotificationObserver observer(
       chrome::NOTIFICATION_SAFE_BROWSING_UPDATE_COMPLETE,
       content::Source<SafeBrowsingDatabaseManager>(
           sb_service_->database_manager().get()));
   BrowserThread::PostTask(
       BrowserThread::IO,
       FROM_HERE,
       base::Bind(&SafeBrowsingDatabaseManagerCookieTest::ForceUpdate, this));
   observer.Wait();
 }