Sanity tweaks to the extension blacklist: check all extensions at once on

chrome/browser/extensions/blacklist.cc

 // 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.
 
 #include "chrome/browser/extensions/blacklist.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/lazy_instance.h"
@@ skipping 94 matching lines @@
     callback_message_loop_->PostTask(FROM_HERE, base::Bind(callback_, hits));
     Release();  // Balanced in StartCheck.
   }
 
   scoped_refptr<base::MessageLoopProxy> callback_message_loop_;
   OnResultCallback callback_;
 
   DISALLOW_COPY_AND_ASSIGN(SafeBrowsingClientImpl);
 };
 
+void IsNotEmpty(const Blacklist::IsBlacklistedCallback& callback,
+                const std::set<std::string>& set) {
+  callback.Run(!set.empty());
+}
+
 }  // namespace
 
 Blacklist::Observer::Observer(Blacklist* blacklist) : blacklist_(blacklist) {
   blacklist_->AddObserver(this);
 }
 
 Blacklist::Observer::~Observer() {
   blacklist_->RemoveObserver(this);
 }
 
@@ skipping 25 matching lines @@
   // altogether (when we're sure it's a strict subset of the safebrowsing one).
 }
 
 Blacklist::~Blacklist() {
 }
 
 void Blacklist::GetBlacklistedIDs(const std::set<std::string>& ids,
                                   const GetBlacklistedIDsCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
+  if (ids.empty()) {
+    base::MessageLoopProxy::current()->PostTask(
+        FROM_HERE,
+        base::Bind(callback, std::set<std::string>()));
+    return;
+  }
+
   // The blacklisted IDs are the union of those blacklisted in prefs and
   // those blacklisted from safe browsing.
   std::set<std::string> pref_blacklisted_ids;
   for (std::set<std::string>::const_iterator it = ids.begin();
        it != ids.end(); ++it) {
     if (prefs_->IsExtensionBlacklisted(*it))
       pref_blacklisted_ids.insert(*it);
   }
 
   if (!g_database_manager.Get().get()) {
     base::MessageLoopProxy::current()->PostTask(
         FROM_HERE,
         base::Bind(callback, pref_blacklisted_ids));
     return;
   }
 
   // Constructing the SafeBrowsingClientImpl begins the process of asking
   // safebrowsing for the blacklisted extensions.
   new SafeBrowsingClientImpl(
       ids,
       base::Bind(&Blacklist::OnSafeBrowsingResponse, AsWeakPtr(),
                  pref_blacklisted_ids,
                  callback));
 }
 
+void Blacklist::IsBlacklisted(const std::string& extension_id,
+                              const IsBlacklistedCallback& callback) {
+  std::set<std::string> check;
+  check.insert(extension_id);
+  GetBlacklistedIDs(check, base::Bind(&IsNotEmpty, callback));
+}
+
 void Blacklist::SetFromUpdater(const std::vector<std::string>& ids,
                                const std::string& version) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   std::set<std::string> ids_as_set;
   for (std::vector<std::string>::const_iterator it = ids.begin();
        it != ids.end(); ++it) {
     if (Extension::IdIsValid(*it))
       ids_as_set.insert(*it);
     else
@@ skipping 63 matching lines @@
 }
 
 void Blacklist::Observe(int type,
                         const content::NotificationSource& source,
                         const content::NotificationDetails& details) {
   DCHECK_EQ(chrome::NOTIFICATION_SAFE_BROWSING_UPDATE_COMPLETE, type);
   FOR_EACH_OBSERVER(Observer, observers_, OnBlacklistUpdated());
 }
 
 }  // namespace extensions