Implement support for checking bad IPs aka MatchMalwareIP

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 77 matching lines @@
     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 represents the case when we're trying to determine if a URL is an
     // unsafe resource.
     CHECK_RESOURCE_URL = 2,
 
-    // This represents the case where we're trying to determine if a Chrome
+    // This represents the case when we're trying to determine if a Chrome
     // extension is a unsafe.
-    CHECK_EXTENSION_IDS = 3
+    CHECK_EXTENSION_IDS = 3,
+
+    // This represents the case when we're trying to determing if an IP address
+    // is unsafe due to hosting Malware.
+    CHECK_MALWARE_IP = 4

[Scott Hess - ex-Googler, 2016/11/15 01:21:10]

Nit: I'd pop a comma, here, so that when you invariably add another element, you
don't have to modify this line.

[vakh (use Gerrit instead), 2016/11/15 01:41:52]

Done.

   };
 
   // The information we need to process a URL safety reputation request and
   // respond to the SafeBrowsing client that asked for it.
   struct PendingCheck {
     PendingCheck(Client* client,
                  ClientCallbackType client_callback_type,
                  const StoresToCheck& stores_to_check,
                  const std::vector<GURL>& urls);
 
@@ skipping 79 matching lines @@
 
   // 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);
 
+  // Checks the database for prefix matches. Returns true if the database isn't
+  // ready or if there's no match; false otherwise. This is used for lists that
+  // have full hash information in the database.
+  bool HandleCheckSynchronously(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_