SafeBrowsing: Implement cache lookup for full hash checks

components/safe_browsing_db/database_manager.h

 // 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.
 //
 // The Safe Browsing service is responsible for downloading anti-phishing and
 // anti-malware tables and checking urls against them.
 
 #ifndef COMPONENTS_SAFE_BROWSING_DB_DATABASE_MANAGER_H_
 #define COMPONENTS_SAFE_BROWSING_DB_DATABASE_MANAGER_H_
 
@@ skipping 162 matching lines @@
   // Called to stop or shutdown operations on the io_thread.
   virtual void StopOnIOThread(bool shutdown);
 
  protected:
   // Bundled client info for an API abuse hash prefix check.
   class SafeBrowsingApiCheck {
    public:
     SafeBrowsingApiCheck(const GURL& url,
                          const std::vector<SBPrefix>& prefixes,
                          const std::vector<SBFullHash>& full_hashes,
+                         const std::vector<SBFullHashResult>& cached_results,
                          Client* client);
     ~SafeBrowsingApiCheck();
 
     const GURL& url() {return url_;}
     const std::vector<SBPrefix>& prefixes() {return prefixes_;}
     const std::vector<SBFullHash>& full_hashes() {return full_hashes_;}
+    const std::vector<SBFullHashResult>& cached_results() {
+        return cached_results_;
+    }
     SafeBrowsingDatabaseManager::Client* client() {return client_;}
 
    private:
     GURL url_;
 
     // Prefixes that were requested in this check.
     std::vector<SBPrefix> prefixes_;
 
     // Full hashes for this check.
     std::vector<SBFullHash> full_hashes_;
 
+    // Cached results for this check.
+    std::vector<SBFullHashResult> cached_results_;
+
     // Not owned.
     SafeBrowsingDatabaseManager::Client* client_;
 
     DISALLOW_COPY_AND_ASSIGN(SafeBrowsingApiCheck);
   };
 
   SafeBrowsingDatabaseManager();
 
   virtual ~SafeBrowsingDatabaseManager();
 
   friend class base::RefCountedThreadSafe<SafeBrowsingDatabaseManager>;
 
   FRIEND_TEST_ALL_PREFIXES(SafeBrowsingDatabaseManagerTest,
                            CheckApiBlacklistUrlPrefixes);
   FRIEND_TEST_ALL_PREFIXES(SafeBrowsingDatabaseManagerTest,
                            HandleGetHashesWithApisResults);
   FRIEND_TEST_ALL_PREFIXES(SafeBrowsingDatabaseManagerTest,
                            HandleGetHashesWithApisResultsNoMatch);
   FRIEND_TEST_ALL_PREFIXES(SafeBrowsingDatabaseManagerTest,
                            HandleGetHashesWithApisResultsMatches);
   FRIEND_TEST_ALL_PREFIXES(SafeBrowsingDatabaseManagerTest,
                            CancelApiCheck);
   FRIEND_TEST_ALL_PREFIXES(SafeBrowsingDatabaseManagerTest,
                            ResultsAreCached);
   FRIEND_TEST_ALL_PREFIXES(SafeBrowsingDatabaseManagerTest,
                            ResultsAreNotCachedOnNull);
+  FRIEND_TEST_ALL_PREFIXES(SafeBrowsingDatabaseManagerTest,
+                           GetCachedResults);
+  FRIEND_TEST_ALL_PREFIXES(SafeBrowsingDatabaseManagerTest,
+                           CachedResultsMerged);
 
   typedef std::set<SafeBrowsingApiCheck*> ApiCheckSet;
   typedef std::map<SBPrefix, SBCachedFullHashResult> PrefixToFullHashResultsMap;
+  typedef std::map<SBThreatType, PrefixToFullHashResultsMap>
+      ThreatTypeToResultsMap;
 
   // Called on the IO thread wheh the SafeBrowsingProtocolManager has received
   // the full hash and api results for prefixes of the |url| argument in
   // CheckApiBlacklistUrl.
   virtual void HandleGetHashesWithApisResults(
       SafeBrowsingApiCheck* check,
       const std::vector<SBFullHashResult>& full_hash_results,
       const base::Time& negative_cache_expire);
 
+  // Looks up the cached results for |threat_type|. Fills |prefixes| with the
+  // prefixes that need a request. Fills |cached_results| with the cached
+  // results.
+  void GetFullHashCachedResults(const SBThreatType& threat_type,
+                                const std::vector<SBFullHash>& full_hashes,
+                                base::Time now,
+                                std::vector<SBPrefix>* prefixes,
+                                std::vector<SBFullHashResult>* cached_results);
+
+  // Populates |md| with permission api metadata from all results that have a
+  // match in |full_hashes|.
+  void PopulateApiMetadataResult(const std::vector<SBFullHashResult>& results,
+                                 const std::vector<SBFullHash>& full_hashes,
+                                 ThreatMetadata* md);
+
   // In-progress checks. This set owns the SafeBrowsingApiCheck pointers and is
   // responsible for deleting them when removing from the set.
   ApiCheckSet api_checks_;
 
   // A cache of V4 full hash results for api checks.
-  PrefixToFullHashResultsMap api_cache_;
+  // TODO(kcarattini): Look into moving all caching logic to
+  // V4GetHashProtocolManager.
+  ThreatTypeToResultsMap v4_full_hash_cache_;
 
   // Created and destroyed via StartOnIOThread/StopOnIOThread.
   V4GetHashProtocolManager* v4_get_hash_protocol_manager_;
 
  private:
   // Returns an iterator to the pending API check with the given |client|.
   ApiCheckSet::iterator FindClientApiCheck(Client* client);
 };  // class SafeBrowsingDatabaseManager
 
 }  // namespace safe_browsing
 
 #endif  // COMPONENTS_SAFE_BROWSING_DB_DATABASE_MANAGER_H_