Only call UrlToFullHashes once from LocalSafeBrowsingDatabaseManager::CheckBrowseUrl

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 "chrome/browser/safe_browsing/safe_browsing_service.h"
 
@@ skipping 33 matching lines @@
 #include "chrome/browser/ui/browser_navigator_params.h"
 #include "chrome/browser/ui/tabs/tab_strip_model.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/test/base/in_process_browser_test.h"
 #include "chrome/test/base/ui_test_utils.h"
 #include "components/bookmarks/browser/startup_task_runner_service.h"
 #include "components/content_settings/core/browser/host_content_settings_map.h"
 #include "components/safe_browsing_db/database_manager.h"
+#include "components/safe_browsing_db/util.h"
 #include "content/public/browser/interstitial_page.h"
 #include "content/public/browser/navigation_entry.h"
 #include "content/public/browser/render_frame_host.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/test/browser_test_utils.h"
 #include "net/cookies/cookie_store.h"
 #include "net/cookies/cookie_util.h"
 #include "net/test/embedded_test_server/embedded_test_server.h"
 #include "net/test/embedded_test_server/http_request.h"
 #include "net/test/embedded_test_server/http_response.h"
@@ skipping 124 matching lines @@
   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();
+    urls_by_hash_.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(MALWARE, PHISH, std::vector<GURL>(1, url), prefix_hits);
   }
+
+  bool ContainsBrowseHashes(
+      const std::vector<SBFullHash>& full_hashes,
+      std::vector<SBPrefix>* prefix_hits,
+      std::vector<SBFullHashResult>* cache_hits) override {
+    cache_hits->clear();
+    return ContainsUrl(MALWARE, PHISH, UrlsForHashes(full_hashes), prefix_hits);
+  }
+
   bool ContainsUnwantedSoftwareUrl(
       const GURL& url,
       std::vector<SBPrefix>* prefix_hits,
       std::vector<SBFullHashResult>* cache_hits) override {
     cache_hits->clear();
     return ContainsUrl(UNWANTEDURL, UNWANTEDURL, std::vector<GURL>(1, url),
                        prefix_hits);
   }
+
+  bool ContainsUnwantedSoftwareHashes(
+      const std::vector<SBFullHash>& full_hashes,
+      std::vector<SBPrefix>* prefix_hits,
+      std::vector<SBFullHashResult>* cache_hits) override {
+    cache_hits->clear();
+    return ContainsUrl(UNWANTEDURL, UNWANTEDURL, UrlsForHashes(full_hashes),
+                       prefix_hits);
+  }
+
   bool ContainsDownloadUrlPrefixes(
       const std::vector<SBPrefix>& prefixes,
       std::vector<SBPrefix>* prefix_hits) override {
     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; }
@@ skipping 37 matching lines @@
   // 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());
     bad_prefixes_.insert(
         std::make_pair(full_hash.list_id, full_hash.hash.prefix));
+    urls_by_hash_[SBFullHashToString(full_hash.hash)] = url;
   }
 
  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,
@@ skipping 15 matching lines @@
               != list_ids_for_url.end()) {
         prefix_hits->insert(prefix_hits->end(),
                             badurls_it->second.prefix_hits.begin(),
                             badurls_it->second.prefix_hits.end());
         hit = true;
       }
     }
     return hit;
   }
 
+  std::vector<GURL> UrlsForHashes(const std::vector<SBFullHash>& full_hashes) {
+    std::vector<GURL> urls;
+    for (auto hash : full_hashes) {
+      auto url_it = urls_by_hash_.find(SBFullHashToString(hash));
+      if (url_it != urls_by_hash_.end()) {
+        urls.push_back(url_it->second);
+      }
+    }
+    return urls;
+  }
+
   bool ContainsUrlPrefixes(int list_id0,
                            int list_id1,
                            const std::vector<SBPrefix>& prefixes,
                            std::vector<SBPrefix>* prefix_hits) {
     bool hit = false;
     for (const SBPrefix& prefix : prefixes) {
       for (const std::pair<int, SBPrefix>& entry : bad_prefixes_) {
         if (entry.second == prefix &&
             (entry.first == list_id0 || entry.first == list_id1)) {
           prefix_hits->push_back(prefix);
           hit = true;
         }
       }
     }
     return hit;
   }
 
   base::hash_map<std::string, Hits> badurls_;
   base::hash_set<std::pair<int, SBPrefix>> bad_prefixes_;
+  base::hash_map<std::string, GURL> urls_by_hash_;
 
   DISALLOW_COPY_AND_ASSIGN(TestSafeBrowsingDatabase);
 };
 
 // Factory that creates TestSafeBrowsingDatabase instances.
 class TestSafeBrowsingDatabaseFactory : public SafeBrowsingDatabaseFactory {
  public:
   TestSafeBrowsingDatabaseFactory() : db_(NULL) {}
   ~TestSafeBrowsingDatabaseFactory() override {}
 
@@ skipping 1294 matching lines @@
       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();
 }
 
 }  // namespace safe_browsing