Mostly integrate new malware IP blacklist with the csd client. When

chrome/browser/safe_browsing/browser_feature_extractor.h

 // Copyright (c) 2011 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.
 //
 // BrowserFeatureExtractor computes various browser features for client-side
 // phishing detection.  For now it does a bunch of lookups in the history
 // service to see whether a particular URL has been visited before by the
 // user.
 
 #ifndef CHROME_BROWSER_SAFE_BROWSING_BROWSER_FEATURE_EXTRACTOR_H_
@@ skipping 19 matching lines @@
 
 class HistoryService;
 
 namespace content {
 class WebContents;
 }
 
 namespace safe_browsing {
 class ClientMalwareRequest;
 class ClientPhishingRequest;
-class ClientSideDetectionService;
+class ClientSideDetectionHost;
 
 typedef std::map<std::string, std::set<std::string> > IPUrlMap;
 
 struct BrowseInfo {
   // List of IPv4 and IPv6 addresses from which content was requested
   // together with the hosts on it, while browsing to the |url|.
   IPUrlMap ips;
 
   // If a SafeBrowsing interstitial was shown for the current URL
   // this will contain the UnsafeResource struct for that URL.
@@ skipping 14 matching lines @@
 
 // All methods of this class must be called on the UI thread (including
 // the constructor).
 class BrowserFeatureExtractor {
  public:
   // Called when feature extraction is done.  The first argument will be
   // true iff feature extraction succeeded.  The second argument is the
   // phishing request which was modified by the feature extractor.  The
   // DoneCallback takes ownership of the request object.
   typedef base::Callback<void(bool, ClientPhishingRequest*)> DoneCallback;
-  typedef base::Callback<void(bool, ClientMalwareRequest*)> MalwareDoneCallback;
+  typedef base::Callback<void(bool, scoped_ptr<ClientMalwareRequest>)>
+      MalwareDoneCallback;
 
-  // The caller keeps ownership of the tab and service objects and is
+  // The caller keeps ownership of the tab and host objects and is
   // responsible for ensuring that they stay valid for the entire
   // lifetime of this object.
   BrowserFeatureExtractor(content::WebContents* tab,
-                          ClientSideDetectionService* service);
+                          ClientSideDetectionHost* host);
 
   // The destructor will cancel any pending requests.
   virtual ~BrowserFeatureExtractor();
 
   // Begins extraction of the browser features.  We take ownership
   // of the request object until |callback| is called (see DoneCallback above)
   // and will write the extracted features to the feature map.  Once the
   // feature extraction is complete, |callback| is run on the UI thread.  We
   // take ownership of the |callback| object.  |info| may not be valid after
   // ExtractFeatures returns.  This method must run on the UI thread.
   virtual void ExtractFeatures(const BrowseInfo* info,
                                ClientPhishingRequest* request,
                                const DoneCallback& callback);
 
-  // Extract the malware related features. The request object is owned by the
-  // caller.
-  virtual void ExtractMalwareFeatures(const BrowseInfo* info,
-                                      ClientMalwareRequest* request);
+  // Begins extraction of the malware related features.  We take ownership
+  // of the request object until |callback| is called.  Once feature extraction
+  // is complete, |callback| will run on the UI thread.  |info| is not expected
+  // to stay valid after ExtractMalwareFeatures returns.  All IPs stored in
+  // |info| will be cleared by calling this function.
+  virtual void ExtractMalwareFeatures(BrowseInfo* info,
+                                      ClientMalwareRequest* request,
+                                      const MalwareDoneCallback& callback);
 
  private:
   friend class base::DeleteHelper<BrowserFeatureExtractor>;
   typedef std::pair<ClientPhishingRequest*, DoneCallback> ExtractionData;
   typedef std::map<CancelableRequestProvider::Handle,
                    ExtractionData> PendingQueriesMap;
 
   // Synchronous browser feature extraction.
   void ExtractBrowseInfoFeatures(const BrowseInfo& info,
                                  ClientPhishingRequest* request);
@@ skipping 42 matching lines @@
   // is a pending query for the given handle it will return false and set both
   // the request and cb pointers.  Otherwise, it will return false.
   bool GetPendingQuery(CancelableRequestProvider::Handle handle,
                        ClientPhishingRequest** request,
                        DoneCallback* callback);
 
   // Helper function which gets the history server if possible.  If the pointer
   // is set it will return true and false otherwise.
   bool GetHistoryService(HistoryService** history);
 
+  // Helper function which is called when we're done filtering out benign IPs
+  // on the IO thread.  This function is called on the UI thread.
+  void FinishExtractMalwareFeatures(scoped_ptr<IPUrlMap> bad_ips,
+                                    MalwareDoneCallback callback,
+                                    scoped_ptr<ClientMalwareRequest> request);
+
   content::WebContents* tab_;
-  ClientSideDetectionService* service_;
+  ClientSideDetectionHost* host_;
   CancelableRequestConsumer request_consumer_;
   base::WeakPtrFactory<BrowserFeatureExtractor> weak_factory_;
 
   // Set of pending extractions (i.e. extractions for which ExtractFeatures was
   // called but not StartExtractFeatures).
   std::map<ClientPhishingRequest*, DoneCallback> pending_extractions_;
 
   // Set of pending queries (i.e., where history->Query...() was called but
   // the history callback hasn't been invoked yet).
   PendingQueriesMap pending_queries_;
 
-  // Max number of malware IPs can be sent in one malware request
-  static const int kMaxMalwareIPPerRequest;
-
   DISALLOW_COPY_AND_ASSIGN(BrowserFeatureExtractor);
 };
 
 }  // namespace safe_browsing
 #endif  // CHROME_BROWSER_SAFE_BROWSING_BROWSER_FEATURE_EXTRACTOR_H_