Safebrowsing: change gethash caching to match api 2.3 rules, fix some corner cases.

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 41 matching lines @@
 using content::WebContents;
 using ::testing::_;
 using ::testing::Mock;
 using ::testing::StrictMock;
 
 namespace {
 
 void InvokeFullHashCallback(
     SafeBrowsingProtocolManager::FullHashCallback callback,
     const std::vector<SBFullHashResult>& result) {
-  callback.Run(result, true);
+  callback.Run(result, base::TimeDelta::FromMinutes(45));
 }
 
 }  // namespace
 
 // A SafeBrowingDatabase class that allows us to inject the malicious URLs.
 class TestSafeBrowsingDatabase :  public SafeBrowsingDatabase {
  public:
   TestSafeBrowsingDatabase() {}
 
   virtual ~TestSafeBrowsingDatabase() {}
 
   // Initializes the database with the given filename.
   virtual void Init(const base::FilePath& filename) OVERRIDE {}
 
   // Deletes the current database and creates a new one.
   virtual 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.
   virtual bool ContainsBrowseUrl(const GURL& url,
-                                 std::string* matching_list,
                                  std::vector<SBPrefix>* prefix_hits,
-                                 std::vector<SBFullHashResult>* full_hits,
-                                 base::Time last_update) OVERRIDE {
+                                 std::vector<SBFullHashResult>* cache_hits)
+      OVERRIDE {
+    cache_hits->clear();
     std::vector<GURL> urls(1, url);
     return ContainsUrl(safe_browsing_util::kMalwareList,
                        safe_browsing_util::kPhishingList,
-                       urls, prefix_hits, full_hits);
+                       urls,
+                       prefix_hits);
   }
   virtual bool ContainsDownloadUrl(
       const std::vector<GURL>& urls,
       std::vector<SBPrefix>* prefix_hits) OVERRIDE {
-    std::vector<SBFullHashResult> full_hits;
     bool found = ContainsUrl(safe_browsing_util::kBinUrlList,
                              safe_browsing_util::kBinUrlList,
-                             urls, prefix_hits, &full_hits);
+                             urls,
+                             prefix_hits);
     if (!found)
       return false;
     DCHECK_LE(1U, prefix_hits->size());
     return true;
   }
   virtual bool ContainsCsdWhitelistedUrl(const GURL& url) OVERRIDE {
     return true;
   }
   virtual bool ContainsDownloadWhitelistedString(
       const std::string& str) OVERRIDE {
@@ skipping 22 matching lines @@
     ADD_FAILURE() << "Not implemented.";
   }
   virtual void DeleteChunks(
       const std::vector<SBChunkDelete>& chunk_deletes) OVERRIDE {
     ADD_FAILURE() << "Not implemented.";
   }
   virtual void UpdateFinished(bool update_succeeded) OVERRIDE {
     ADD_FAILURE() << "Not implemented.";
   }
   virtual void CacheHashResults(const std::vector<SBPrefix>& prefixes,
-      const std::vector<SBFullHashResult>& full_hits) OVERRIDE {
+                                const std::vector<SBFullHashResult>& full_hits,
+                                const base::TimeDelta& cache_lifetime)
+      OVERRIDE {
     // Do nothing for the cache.
   }
   virtual bool IsMalwareIPMatchKillSwitchOn() OVERRIDE {
     return false;
   }
 
   // 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) {
+              const std::vector<SBPrefix>& prefix_hits) {
     badurls_[url.spec()].list_name = list_name;
     badurls_[url.spec()].prefix_hits = prefix_hits;
-    badurls_[url.spec()].full_hits = full_hits;
   }
 
   // Fill up the database with test hash digest.
   void AddDownloadPrefix(SBPrefix prefix) {
     download_digest_prefix_.insert(prefix);
   }
 
  private:
   struct Hits {
     std::string list_name;
     std::vector<SBPrefix> prefix_hits;
-    std::vector<SBFullHashResult> full_hits;
   };
 
   bool ContainsUrl(const std::string& list_name0,
                    const std::string& list_name1,
                    const std::vector<GURL>& urls,
-                   std::vector<SBPrefix>* prefix_hits,
-                   std::vector<SBFullHashResult>* full_hits) {
+                   std::vector<SBPrefix>* prefix_hits) {
     bool hit = false;
     for (size_t i = 0; i < urls.size(); ++i) {
       const GURL& url = urls[i];
       base::hash_map<std::string, Hits>::const_iterator
           badurls_it = badurls_.find(url.spec());
 
       if (badurls_it == badurls_.end())
         continue;
 
       if (badurls_it->second.list_name == list_name0 ||
           badurls_it->second.list_name == list_name1) {
         prefix_hits->insert(prefix_hits->end(),
                             badurls_it->second.prefix_hits.begin(),
                             badurls_it->second.prefix_hits.end());
-        full_hits->insert(full_hits->end(),
-                          badurls_it->second.full_hits.begin(),
-                          badurls_it->second.full_hits.end());
         hit = true;
       }
 
     }
     return hit;
   }
 
   base::hash_map<std::string, Hits> badurls_;
   base::hash_set<SBPrefix> download_digest_prefix_;
 };
@@ skipping 128 matching lines @@
 
   static void GenUrlFullhashResult(const GURL& url,
                                    const std::string& list_name,
                                    int add_chunk_id,
                                    SBFullHashResult* full_hash) {
     std::string host;
     std::string path;
     safe_browsing_util::CanonicalizeUrl(url, &host, &path, NULL);
     full_hash->hash = SBFullHashForString(host + path);
     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) {
     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 20 matching lines @@
   // This will setup the "url" prefix in database and prepare protocol manager
   // to response with |full_hash| for get full hash request.
   void SetupResponseForUrl(const GURL& url, const SBFullHashResult& full_hash) {
     std::vector<SBPrefix> prefix_hits;
     prefix_hits.push_back(full_hash.hash.prefix);
 
     // Make sure the full hits is empty unless we need to test the
     // 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);
+    db->AddUrl(url, full_hash.list_name, prefix_hits);
 
     TestProtocolManager* pm = pm_factory_.GetProtocolManager();
     pm->SetGetFullHashResponse(full_hash);
   }
 
   // This will setup the binary digest prefix in database and prepare protocol
   // manager to respond with the result hash.
   void SetupResponseForDigest(const std::string& digest,
                               const SBFullHashResult& hash_result) {
     TestSafeBrowsingDatabase* db = db_factory_.GetDb();
@@ skipping 568 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();
 }