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 60 matching lines @@
   // Must be initialized by calling StartOnIOThread() before using.
   V4LocalDatabaseManager(const base::FilePath& base_path);
 
   ~V4LocalDatabaseManager() override;
 
   void SetTaskRunnerForTest(
       const scoped_refptr<base::SequencedTaskRunner>& task_runner) {
     task_runner_ = task_runner;
   }
 
   enum class ClientCallbackType {

[Nathan Parker, 2016/10/26 00:45:45]

Nit: Could this and the PendingCheck go in the .cc file? It's an implenentation
detail, so it'd make the .h easier to read for clients calling this.

Looks like PendingCheck is only referenced by ptr.

[vakh (use Gerrit instead), 2016/10/26 19:53:22]

Done.

     // 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 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,
+
     // This should always be the last value.
     CHECK_MAX

[Nathan Parker, 2016/10/26 00:45:45]

Nit: you don't really need a max if you're going to have a specific branch of
code for each value, since you'll detect bad ones there.

[vakh (use Gerrit instead), 2016/10/26 19:53:22]

Done.

   };
 
   // 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.

[Nathan Parker, 2016/10/26 00:45:45]

URL(s) that are...

[vakh (use Gerrit instead), 2016/10/26 19:53:21]

Done.

-    GURL url;
+    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_