Small modifications to safebrowsing code to make it simpler to add the extension

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>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/file_path.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/memory/ref_counted.h"
 #include "base/path_service.h"
 #include "base/string_split.h"
 #include "base/test/thread_test_helper.h"
+#include "base/time.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/prefs/pref_service.h"
 #include "chrome/browser/prerender/prerender_manager.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/profiles/profile_manager.h"
 #include "chrome/browser/safe_browsing/client_side_detection_service.h"
 #include "chrome/browser/safe_browsing/database_manager.h"
 #include "chrome/browser/safe_browsing/protocol_manager.h"
 #include "chrome/browser/safe_browsing/safe_browsing_database.h"
 #include "chrome/browser/safe_browsing/safe_browsing_service.h"
@@ skipping 94 matching lines @@
   }
   virtual void DeleteChunks(const std::vector<SBChunkDelete>& chunk_deletes) {
     ADD_FAILURE() << "Not implemented.";
   }
   virtual void UpdateFinished(bool update_succeeded) {
     ADD_FAILURE() << "Not implemented.";
   }
   virtual void CacheHashResults(const std::vector<SBPrefix>& prefixes,
       const std::vector<SBFullHashResult>& full_hits) {
     // Do nothing for the cache.
-    return;
   }
 
   // Fill up the database with test URL.
   void AddUrl(const GURL& url,
               const std::string& list_name,
               const std::vector<SBPrefix>& prefix_hits,
               const std::vector<SBFullHashResult>& full_hits) {
     badurls_[url.spec()].list_name = list_name;
     badurls_[url.spec()].prefix_hits = prefix_hits;
     badurls_[url.spec()].full_hits = full_hits;
@@ skipping 65 matching lines @@
   TestSafeBrowsingDatabase* db_;
 };
 
 // A TestProtocolManager that could return fixed responses from
 // safebrowsing server for testing purpose.
 class TestProtocolManager :  public SafeBrowsingProtocolManager {
  public:
   TestProtocolManager(SafeBrowsingProtocolManagerDelegate* delegate,
                       net::URLRequestContextGetter* request_context_getter,
                       const SafeBrowsingProtocolConfig& config)
-      : SafeBrowsingProtocolManager(delegate, request_context_getter, config),
-        delay_ms_(0) {
+      : SafeBrowsingProtocolManager(delegate, request_context_getter, config) {
     create_count_++;
   }
 
   ~TestProtocolManager() {
     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.
   virtual void GetFullHash(
       const std::vector<SBPrefix>& prefixes,
       SafeBrowsingProtocolManager::FullHashCallback callback,
       bool is_download) OVERRIDE {
     BrowserThread::PostDelayedTask(
         BrowserThread::IO, FROM_HERE,
         base::Bind(InvokeFullHashCallback, callback, full_hashes_),
-        base::TimeDelta::FromMilliseconds(delay_ms_));
+        delay_);
   }
 
   // Prepare the GetFullHash results for the next request.
   void SetGetFullHashResponse(const SBFullHashResult& full_hash_result) {
     full_hashes_.clear();
     full_hashes_.push_back(full_hash_result);
   }
 
-  void IntroduceDelay(int64 ms) {
-    delay_ms_ = ms;
+  void IntroduceDelay(const base::TimeDelta& delay) {
+    delay_ = delay;
   }
 
   static int create_count() {
     return create_count_;
   }
 
   static int delete_count() {
     return delete_count_;
   }
 
  private:
   std::vector<SBFullHashResult> full_hashes_;
-  int64 delay_ms_;
+  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.
@@ skipping 48 matching lines @@
     crypto::SHA256HashString(host + path, &full_hash->hash,
                              sizeof(SBFullHash));
     full_hash->list_name = list_name;
     full_hash->add_chunk_id = add_chunk_id;
   }
 
   static void GenDigestFullhashResult(const std::string& full_digest,
                                       const std::string& list_name,
                                       int add_chunk_id,
                                       SBFullHashResult* full_hash) {
-    safe_browsing_util::StringToSBFullHash(full_digest, &full_hash->hash);
+    full_hash->hash = safe_browsing_util::StringToSBFullHash(full_digest);
     full_hash->list_name = list_name;
     full_hash->add_chunk_id = add_chunk_id;
   }
 
   virtual void SetUp() {
     // InProcessBrowserTest::SetUp() instantiates SafebrowsingService and
     // RegisterFactory has to be called before SafeBrowsingService is created.
     SafeBrowsingDatabase::RegisterFactory(&db_factory_);
     SafeBrowsingProtocolManager::RegisterFactory(&pm_factory_);
     InProcessBrowserTest::SetUp();
@@ skipping 29 matching lines @@
     // full hash is hit in database's local cache.
     std::vector<SBFullHashResult> empty_full_hits;
     TestSafeBrowsingDatabase* db = db_factory_.GetDb();
     db->AddUrl(url, full_hash.list_name, prefix_hits, empty_full_hits);
 
     TestProtocolManager* pm = pm_factory_.GetProtocolManager();
     pm->SetGetFullHashResponse(full_hash);
   }
 
   // This will setup the binary digest prefix in database and prepare protocol
-  // manager to response with |full_hash| for get full hash request.
+  // manager to respond with the result hash.
   void SetupResponseForDigest(const std::string& digest,
                               const SBFullHashResult& hash_result) {
     TestSafeBrowsingDatabase* db = db_factory_.GetDb();
-    SBFullHash full_hash;
-    safe_browsing_util::StringToSBFullHash(digest, &full_hash);
-    db->AddDownloadPrefix(full_hash.prefix);
+    db->AddDownloadPrefix(
+        safe_browsing_util::StringToSBFullHash(digest).prefix);
 
     TestProtocolManager* pm = pm_factory_.GetProtocolManager();
     pm->SetGetFullHashResponse(hash_result);
   }
 
   bool ShowingInterstitialPage() {
     WebContents* contents = chrome::GetActiveWebContents(browser());
     InterstitialPage* interstitial_page = contents->GetInterstitialPage();
     return interstitial_page != NULL;
   }
 
-  void IntroduceGetHashDelay(int64 ms) {
-    pm_factory_.GetProtocolManager()->IntroduceDelay(ms);
+  void IntroduceGetHashDelay(const base::TimeDelta& delay) {
+    pm_factory_.GetProtocolManager()->IntroduceDelay(delay);
   }
 
-  int64 DownloadUrlCheckTimeout(SafeBrowsingService* sb_service) {
-    return sb_service->database_manager()->download_urlcheck_timeout_ms_;
+  base::TimeDelta GetCheckTimeout(SafeBrowsingService* sb_service) {
+    return sb_service->database_manager()->check_timeout_;
   }
 
-  int64 DownloadHashCheckTimeout(SafeBrowsingService* sb_service) {
-    return sb_service->database_manager()->download_hashcheck_timeout_ms_;
-  }
-
-  void SetDownloadUrlCheckTimeout(SafeBrowsingService* sb_service, int64 ms) {
-    sb_service->database_manager()->download_urlcheck_timeout_ms_ = ms;
-  }
-
-  void SetDownloadHashCheckTimeout(SafeBrowsingService* sb_service, int64 ms) {
-    sb_service->database_manager()->download_hashcheck_timeout_ms_ = ms;
+  void SetCheckTimeout(SafeBrowsingService* sb_service,
+                       const base::TimeDelta& delay) {
+    sb_service->database_manager()->check_timeout_ = delay;
   }
 
   void CreateCSDService() {
     safe_browsing::ClientSideDetectionService* csd_service =
         safe_browsing::ClientSideDetectionService::Create(NULL);
     SafeBrowsingService* sb_service =
         g_browser_process->safe_browsing_service();
     sb_service->csd_service_.reset(csd_service);
     sb_service->RefreshState();
   }
@@ skipping 259 matching lines @@
   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();
-  const int64 kOneSec = 1000;
-  const int64 kOneMs = 1;
-  int64 default_urlcheck_timeout = DownloadUrlCheckTimeout(sb_service);
-  IntroduceGetHashDelay(kOneSec);
-  SetDownloadUrlCheckTimeout(sb_service, kOneMs);
+  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.
-  SetDownloadHashCheckTimeout(sb_service, default_urlcheck_timeout);
+  SetCheckTimeout(sb_service, default_urlcheck_timeout);
 }
 
 IN_PROC_BROWSER_TEST_F(SafeBrowsingServiceTest, CheckDownloadHashTimedOut) {
   const std::string full_hash = "12345678902234567890323456789012";
 
   scoped_refptr<TestSBClient> client(new TestSBClient);
   SBFullHashResult full_hash_result;
   int chunk_id = 0;
   GenDigestFullhashResult(full_hash, safe_browsing_util::kBinHashList,
                           chunk_id, &full_hash_result);
   SetupResponseForDigest(full_hash, full_hash_result);
   client->CheckDownloadHash(full_hash);
 
   // The badbin_url is not safe since it is added to download database.
   EXPECT_EQ(SB_THREAT_TYPE_BINARY_MALWARE_HASH, client->GetThreatType());
 
   //
   // Now introducing delays and we should hit timeout.
   //
   SafeBrowsingService* sb_service = g_browser_process->safe_browsing_service();
-  const int64 kOneSec = 1000;
-  const int64 kOneMs = 1;
-  int64 default_hashcheck_timeout = DownloadHashCheckTimeout(sb_service);
-  IntroduceGetHashDelay(kOneSec);
-  SetDownloadHashCheckTimeout(sb_service, kOneMs);
+  base::TimeDelta default_hashcheck_timeout =
+      GetCheckTimeout(sb_service);
+  IntroduceGetHashDelay(base::TimeDelta::FromSeconds(1));
+  SetCheckTimeout(sb_service, base::TimeDelta::FromMilliseconds(1));
   client->CheckDownloadHash(full_hash);
 
   // 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.
-  SetDownloadHashCheckTimeout(sb_service, default_hashcheck_timeout);
+  SetCheckTimeout(sb_service, default_hashcheck_timeout);
 }
 
 IN_PROC_BROWSER_TEST_F(SafeBrowsingServiceTest, StartAndStop) {
   CreateCSDService();
   SafeBrowsingService* sb_service = g_browser_process->safe_browsing_service();
   safe_browsing::ClientSideDetectionService* csd_service =
       sb_service->safe_browsing_detection_service();
   PrefService* pref_service = browser()->profile()->GetPrefs();
 
   ASSERT_TRUE(sb_service != NULL);
@@ skipping 229 matching lines @@
                        TestSBUpdateCookies) {
   content::WindowedNotificationObserver observer(
       chrome::NOTIFICATION_SAFE_BROWSING_UPDATE_COMPLETE,
       content::Source<SafeBrowsingDatabaseManager>(
           sb_service_->database_manager()));
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
       base::Bind(&SafeBrowsingDatabaseManagerCookieTest::ForceUpdate, this));
   observer.Wait();
 }