Add a GetFullHashWithApis method to Protocol Manager.

chrome/browser/safe_browsing/protocol_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.
 
 #ifndef CHROME_BROWSER_SAFE_BROWSING_PROTOCOL_MANAGER_H_
 #define CHROME_BROWSER_SAFE_BROWSING_PROTOCOL_MANAGER_H_
 
 // A class that implements Chrome's interface with the SafeBrowsing protocol.
 // See https://developers.google.com/safe-browsing/developers_guide_v2 for
 // protocol details.
@@ skipping 10 matching lines @@
 #include "base/containers/hash_tables.h"
 #include "base/gtest_prod_util.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/threading/non_thread_safe.h"
 #include "base/time/time.h"
 #include "base/timer/timer.h"
 #include "chrome/browser/safe_browsing/chunk_range.h"
 #include "chrome/browser/safe_browsing/protocol_manager_helper.h"
 #include "chrome/browser/safe_browsing/protocol_parser.h"
 #include "chrome/browser/safe_browsing/safe_browsing_util.h"
+#include "components/safe_browsing_db/safebrowsing.pb.h"
 #include "net/url_request/url_fetcher_delegate.h"
 #include "net/url_request/url_request_status.h"
 #include "url/gurl.h"
 
 namespace net {
 class URLFetcher;
 class URLRequestContextGetter;
 }  // namespace net
 
 namespace safe_browsing {
@@ skipping 35 matching lines @@
   void OnURLFetchComplete(const net::URLFetcher* source) override;
 
   // Retrieve the full hash for a set of prefixes, and invoke the callback
   // argument when the results are retrieved. The callback may be invoked
   // synchronously.
   virtual void GetFullHash(const std::vector<SBPrefix>& prefixes,
                            FullHashCallback callback,
                            bool is_download,
                            bool is_extended_reporting);
 
+  // Retrieve the full hash for a set of prefixes, and invoke the callback
+  // argument when the results are retrieved. The callback may be invoked
+  // synchronously. Uses the V4 Safe Browsing protocol.
+  virtual void GetV4FullHashes(const std::vector<SBPrefix>& prefixes,
+                               ThreatType threat_type,
+                               FullHashCallback callback);
+
+  // Retrieve the full hash and API metadata for a set of prefixes, and invoke
+  // the callback argument when the results are retrieved. The callback may be
+  // invoked synchronously. Uses the V4 Safe Browsing protocol.
+  virtual void GetFullHashesWithApis(const std::vector<SBPrefix>& prefixes,
+                                     FullHashCallback callback);
+
   // Forces the start of next update after |interval| time.
   void ForceScheduleNextUpdate(base::TimeDelta interval);
 
   // Scheduled update callback.
   void GetNextUpdate();
 
   // Called by the SafeBrowsingService when our request for a list of all chunks
   // for each list is done.  If database_error is true, that means the protocol
   // manager shouldn't fetch updates since they can't be written to disk.  It
   // should try again later to open the database.
@@ skipping 82 matching lines @@
   SafeBrowsingProtocolManager(
       SafeBrowsingProtocolManagerDelegate* delegate,
       net::URLRequestContextGetter* request_context_getter,
       const SafeBrowsingProtocolConfig& config);
 
  private:
   FRIEND_TEST_ALL_PREFIXES(SafeBrowsingProtocolManagerTest, TestBackOffTimes);
   FRIEND_TEST_ALL_PREFIXES(SafeBrowsingProtocolManagerTest, TestChunkStrings);
   FRIEND_TEST_ALL_PREFIXES(SafeBrowsingProtocolManagerTest, TestGetHashUrl);
   FRIEND_TEST_ALL_PREFIXES(SafeBrowsingProtocolManagerTest,
+                           TestGetV4HashUrl);
+  FRIEND_TEST_ALL_PREFIXES(SafeBrowsingProtocolManagerTest,
+                           TestGetV4HashRequest);
+  FRIEND_TEST_ALL_PREFIXES(SafeBrowsingProtocolManagerTest,
                            TestGetHashBackOffTimes);
   FRIEND_TEST_ALL_PREFIXES(SafeBrowsingProtocolManagerTest, TestNextChunkUrl);
   FRIEND_TEST_ALL_PREFIXES(SafeBrowsingProtocolManagerTest, TestUpdateUrl);
   friend class SafeBrowsingServerTest;
   friend class SBProtocolManagerFactoryImpl;
 
   // Internal API for fetching information from the SafeBrowsing servers. The
   // GetHash requests are higher priority since they can block user requests
   // so are handled separately.
   enum SafeBrowsingRequestType {
@@ skipping 15 matching lines @@
   GURL UpdateUrl(bool is_extended_reporting) const;
 
   // Generates backup Update URL for querying about the latest set of chunk
   // updates. |url_prefix| is the base prefix to use.
   GURL BackupUpdateUrl(BackupUpdateReason reason) const;
 
   // Generates GetHash request URL for retrieving full hashes.
   GURL GetHashUrl(bool is_extended_reporting) const;
   // Generates URL for reporting safe browsing hits for UMA users.
 
+  // Generates GetHashWithApis Pver4 request URL for retrieving full hashes.
+  // |request_base64| is the serialized FindFullHashesRequest protocol buffer
+  // encoded in base 64.
+  GURL GetV4HashUrl(const std::string& request_base64) const;
+
+  // Fills a FindFullHashesRequest protocol buffer for an API_ABUSE request.
+  // Returns the serialized and base 64 encoded request as a string.
+  std::string GetV4HashRequest(const std::vector<SBPrefix>& prefixes,
+                               ThreatType threat_type);
+
   // Composes a ChunkUrl based on input string.
   GURL NextChunkUrl(const std::string& input) const;
 
   // Returns the time for the next update request. If |back_off| is true,
   // the time returned will increment an error count and return the appriate
   // next time (see ScheduleNextUpdate below).
   base::TimeDelta GetNextUpdateInterval(bool back_off);
 
   // Worker function for calculating GetHash and Update backoff times (in
   // seconds). |multiplier| is doubled for each consecutive error between the
@@ skipping 93 matching lines @@
   base::OneShotTimer update_timer_;
 
   // timeout_timer_ is used to interrupt update requests which are taking
   // too long.
   base::OneShotTimer timeout_timer_;
 
   // All chunk requests that need to be made.
   std::deque<ChunkUrl> chunk_request_urls_;
 
   HashRequests hash_requests_;
+  HashRequests v4_hash_requests_;
 
   // True if the service has been given an add/sub chunk but it hasn't been
   // added to the database yet.
   bool chunk_pending_to_write_;
 
   // The last time we successfully received an update.
   base::Time last_update_;
 
   // While in GetHash backoff, we can't make another GetHash until this time.
   base::Time next_gethash_time_;
@@ skipping 92 matching lines @@
       AddChunksCallback callback) = 0;
 
   // Delete chunks from the database.
   virtual void DeleteChunks(
       scoped_ptr<std::vector<SBChunkDelete> > chunk_deletes) = 0;
 };
 
 }  // namespace safe_browsing
 
 #endif  // CHROME_BROWSER_SAFE_BROWSING_PROTOCOL_MANAGER_H_