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
   };
 
   // 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 76 matching lines @@
       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);
+  // schedules a task to perform full hash check and returns false. If
+  // |synchronous_response| is false, an asynchronous full hash request to
+  // fetch full hashes for the matching hash prefixes is sent to the
+  // SafeBrowsing service.
+  bool HandleCheck(std::unique_ptr<PendingCheck> check,
+                   const bool synchronous_response = false);

[Nathan Parker, 2016/11/14 21:09:37]

I think this arg is confusing... I've commented in the .cc for a possible soln

[vakh (use Gerrit instead), 2016/11/15 00:36:21]

Done.

+
+  static bool IPAddressToEncodedIPV6(const std::string& ip_address,
+                                     std::string* encoded_ip);
 
   // 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&
@@ skipping 61 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_