Small: Implement CheckDownloadUrls -- not called yet.

components/safe_browsing_db/v4_local_database_manager.h

 // Copyright 2016 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 COMPONENTS_SAFE_BROWSING_DB_V4_LOCAL_DATABASE_MANAGER_H_
 #define COMPONENTS_SAFE_BROWSING_DB_V4_LOCAL_DATABASE_MANAGER_H_
 
 // A class that provides the interface between the SafeBrowsing protocol manager
 // and database that holds the downloaded updates.
 
@@ skipping 65 matching lines @@
   void SetTaskRunnerForTest(
       const scoped_refptr<base::SequencedTaskRunner>& task_runner) {
     task_runner_ = task_runner;
   }
 
   enum class ClientCallbackType {
     // This represents the case when we're trying to determine if a URL is
     // unsafe from the following perspectives: Malware, Phishing, UwS.
     CHECK_BROWSE_URL = 0,
 
-    // This should always be the last value.
-    CHECK_MAX
+    // This represents the case when we're trying to determine if any of the
+    // URLs in a vector of URLs is unsafe for downloading binaries.
+    CHECK_DOWNLOAD_URLS = 1,
   };
 
   // The information we need to process a URL safety reputation request and
   // respond to the SafeBrowsing client that asked for it.
   // TODO(vakh): In its current form, it only includes information for
-  // |CheckBrowseUrl| method. Extend it to serve other methods on |client|.
+  // |CheckBrowseUrl| and |CheckDownloadUrl| methods. Extend it to serve other
+  // methods on |client|.
   struct PendingCheck {
     PendingCheck(Client* client,
                  ClientCallbackType client_callback_type,
                  const StoresToCheck& stores_to_check,
-                 const GURL& url);
+                 const std::vector<GURL>& urls);
 
     ~PendingCheck();
 
     // The SafeBrowsing client that's waiting for the safe/unsafe verdict.
     Client* client;
 
     // Determines which funtion from the |client| needs to be called once we
     // know whether the URL in |url| is safe or unsafe.
-    ClientCallbackType client_callback_type;
+    const ClientCallbackType client_callback_type;
 
     // The threat verdict for the URL being checked.
     SBThreatType result_threat_type;
 
     // When the check was sent to the SafeBrowsing service. Used to record the
     // time it takes to get the uncached full hashes from the service (or a
     // cached full hash response).
     base::TimeTicks full_hash_check_start;
 
     // The SafeBrowsing lists to check hash prefixes in.
-    StoresToCheck stores_to_check;
+    const StoresToCheck stores_to_check;
 
-    // The URL that is being checked for being unsafe.
-    GURL url;
+    // The URLs that are being checked for being unsafe.
+    const std::vector<GURL> urls;
 
     // The metadata associated with the full hash of the severest match found
     // for that URL.
     ThreatMetadata url_metadata;
   };
 
   typedef std::vector<std::unique_ptr<PendingCheck>> QueuedChecks;
 
   // The stores/lists to always get full hashes for, regardless of which store
   // the hash prefix matched.
   StoresToCheck GetStoresForFullHashRequests() override;
 
  private:
   friend class V4LocalDatabaseManagerTest;
   FRIEND_TEST_ALL_PREFIXES(V4LocalDatabaseManagerTest,
                            TestGetSeverestThreatTypeAndMetadata);
 
   // The set of clients awaiting a full hash response. It is used for tracking
   // which clients have cancelled their outstanding request.
-  typedef std::unordered_set<Client*> PendingClients;
+  typedef std::unordered_set<const Client*> PendingClients;
 
   // Called when all the stores managed by the database have been read from
   // disk after startup and the database is ready for checking resource
   // reputation.
   void DatabaseReadyForChecks(std::unique_ptr<V4Database> v4_database);
 
   // Called when all the stores managed by the database have been verified for
   // checksum correctness after startup and the database is ready for applying
   // updates.
   void DatabaseReadyForUpdates(
@@ skipping 11 matching lines @@
   // Finds the most severe |SBThreatType| and the corresponding |metadata| from
   // |full_hash_infos|.
   void GetSeverestThreatTypeAndMetadata(
       SBThreatType* result_threat_type,
       ThreatMetadata* metadata,
       const std::vector<FullHashInfo>& full_hash_infos);
 
   // Returns the SBThreatType for a given ListIdentifier.
   SBThreatType GetSBThreatTypeForList(const ListIdentifier& list_id);
 
+  // Queues the check for async response if the database isn't ready yet.
+  // If the database is ready, checks the database for prefix matches and
+  // returns true immediately if there's no match. If a match is found, it
+  // schedules a task to perform full hash check and returns false.
+  bool HandleCheck(std::unique_ptr<PendingCheck> check);
+
   // Called when the |v4_get_hash_protocol_manager_| has the full hash response
   // available for the URL that we requested. It determines the severest
   // threat type and responds to the |client| with that information.
   void OnFullHashResponse(std::unique_ptr<PendingCheck> pending_check,
                           const std::vector<FullHashInfo>& full_hash_infos);
 
   // Performs the full hash checking of the URL in |check|.
   virtual void PerformFullHashCheck(std::unique_ptr<PendingCheck> check,
                                     const FullHashToStoreAndHashPrefixesMap&
                                         full_hash_to_store_and_hash_prefixes);
@@ skipping 60 matching lines @@
 
   base::WeakPtrFactory<V4LocalDatabaseManager> weak_factory_;
 
   friend class base::RefCountedThreadSafe<V4LocalDatabaseManager>;
   DISALLOW_COPY_AND_ASSIGN(V4LocalDatabaseManager);
 };  // class V4LocalDatabaseManager
 
 }  // namespace safe_browsing
 
 #endif  // COMPONENTS_SAFE_BROWSING_DB_V4_LOCAL_DATABASE_MANAGER_H_