Fetch extension blacklist states from SafeBrowsing server

chrome/browser/extensions/blacklist.h

 // Copyright 2012 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 CHROME_BROWSER_EXTENSIONS_BLACKLIST_H_
 #define CHROME_BROWSER_EXTENSIONS_BLACKLIST_H_
 
+#include <list>
 #include <map>
 #include <set>
 #include <string>
 #include <vector>
 
 #include "base/callback.h"
+#include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
 #include "base/observer_list.h"
 #include "chrome/browser/safe_browsing/database_manager.h"
 #include "content/public/browser/notification_observer.h"
 #include "content/public/browser/notification_registrar.h"
 
 namespace extensions {
 
+class BlacklistStateFetcher;
 class Extension;
 class ExtensionPrefs;
 
 // The blacklist of extensions backed by safe browsing.
 class Blacklist : public content::NotificationObserver,
                   public base::SupportsWeakPtr<Blacklist> {
  public:
   class Observer {
    public:
     // Observes |blacklist| on construction and unobserves on destruction.
@@ skipping 14 matching lines @@
         scoped_refptr<SafeBrowsingDatabaseManager> database_manager);
 
     ~ScopedDatabaseManagerForTest();
 
    private:
     scoped_refptr<SafeBrowsingDatabaseManager> original_;
 
     DISALLOW_COPY_AND_ASSIGN(ScopedDatabaseManagerForTest);
   };
 
-  // The numeric values here match the values of the respective enum in proto
-  // received from SafeBrowsing server.
+  // The numeric values here match the values of the respective enum in
+  // ClientCRXListInfoResponse proto.
   enum BlacklistState {
     NOT_BLACKLISTED = 0,
     BLACKLISTED_MALWARE = 1,
     BLACKLISTED_SECURITY_VULNERABILITY = 2,
     BLACKLISTED_CWS_POLICY_VIOLATION = 3,
-    BLACKLISTED_POTENTIALLY_UNWANTED = 4
+    BLACKLISTED_POTENTIALLY_UNWANTED = 4,
+    BLACKLISTED_UNKNOWN  // Used when we couldn't connect to server,
+                         // e.g. when offline.
   };
 
   typedef std::map<std::string, BlacklistState> BlacklistStateMap;
 
   typedef base::Callback<void(const BlacklistStateMap&)>
       GetBlacklistedIDsCallback;
 
   typedef base::Callback<void(const std::set<std::string>&)>
       GetMalwareIDsCallback;
 
@@ skipping 18 matching lines @@
   // marked in the blacklist as BLACKLISTED_MALWARE and asynchronously pass
   // to |callback|. Basically, will call GetBlacklistedIDs and filter its
   // results.
   void GetMalwareIDs(const std::set<std::string>& ids,
                      const GetMalwareIDsCallback& callback);
 
   // More convenient form of GetBlacklistedIDs for checking a single extension.
   void IsBlacklisted(const std::string& extension_id,
                      const IsBlacklistedCallback& callback);
 
+  // Used to mock BlacklistStateFetcher in unit tests.
+  void SetBlacklistStateFetcherForTest(BlacklistStateFetcher* fetcher);
+
   // Adds/removes an observer to the blacklist.
   void AddObserver(Observer* observer);
   void RemoveObserver(Observer* observer);
 
  private:
   // Use via ScopedDatabaseManagerForTest.
   static void SetDatabaseManager(
       scoped_refptr<SafeBrowsingDatabaseManager> database_manager);
   static scoped_refptr<SafeBrowsingDatabaseManager> GetDatabaseManager();
 
   // content::NotificationObserver
   virtual void Observe(int type,
                        const content::NotificationSource& source,
                        const content::NotificationDetails& details) OVERRIDE;
 
   void GetBlacklistStateForIDs(const GetBlacklistedIDsCallback& callback,
                                const std::set<std::string>& blacklisted_ids);
 
-  void RequestExtensionsBlacklistState(const std::set<std::string> ids,
-                                       base::Callback<void()> callback);
+  void RequestExtensionsBlacklistState(const std::set<std::string>& ids,
+                                       const base::Callback<void()>& callback);
+
+  void OnBlacklistStateReceived(const std::string& id, BlacklistState state);
 
   void ReturnBlacklistStateMap(const GetBlacklistedIDsCallback& callback,
                                const std::set<std::string>& blacklisted_ids);
 
   ObserverList<Observer> observers_;
 
   content::NotificationRegistrar registrar_;
 
+  // The cached BlacklistState's, received from BlacklistStateFetcher.
   BlacklistStateMap blacklist_state_cache_;
 
+  scoped_ptr<BlacklistStateFetcher> state_fetcher_;
+
+  typedef std::list<std::pair<std::vector<std::string>,
+                              base::Callback<void()> > >
+      StateRequestsList;
+
+  // The list of ongoing requests for blacklist states that couldn't be
+  // served directly from the cache. A new request is created in
+  // GetBlacklistedIDs and deleted when the callback is called from
+  // OnBlacklistStateReceived.
+  StateRequestsList state_requests_;
+
   DISALLOW_COPY_AND_ASSIGN(Blacklist);
 };
 
 }  // namespace extensions
 
 #endif  // CHROME_BROWSER_EXTENSIONS_BLACKLIST_H_