Implement loading blacklists from extensions....

chrome/browser/extensions/extensions_service.cc

 // Copyright (c) 2009 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/extensions_service.h"
 
 #include "base/command_line.h"
 #include "base/file_util.h"
 #include "base/string_util.h"
 #include "base/values.h"
@@ skipping 315 matching lines @@
           NewRunnableMethod(
               context_getter,
               &ChromeURLRequestContextGetter::OnNewExtensions,
               extension->id(),
               extension->path()));
     }
   }
 
   NotificationService::current()->Notify(
       NotificationType::EXTENSION_LOADED,
-      Source<ExtensionsService>(this),
+      Source<Profile>(profile_),
       Details<Extension>(extension));
 }
 
 void ExtensionsService::NotifyExtensionUnloaded(Extension* extension) {
   LOG(INFO) << "Sending EXTENSION_UNLOADED";
 
   NotificationService::current()->Notify(
       NotificationType::EXTENSION_UNLOADED,
-      Source<ExtensionsService>(this),
+      Source<Profile>(profile_),
       Details<Extension>(extension));
 
   if (profile_ && !profile_->IsOffTheRecord()) {
     ChromeURLRequestContextGetter* context_getter =
         static_cast<ChromeURLRequestContextGetter*>(
             profile_->GetRequestContext());
     if (context_getter) {
       ChromeThread::PostTask(
           ChromeThread::IO, FROM_HERE,
           NewRunnableMethod(
@@ skipping 54 matching lines @@
   ExtensionDOMUI::UnregisterChromeURLOverrides(profile_,
       extension->GetChromeURLOverrides());
 
   ExtensionList::iterator iter = std::find(disabled_extensions_.begin(),
                                            disabled_extensions_.end(),
                                            extension.get());
   if (iter != disabled_extensions_.end()) {
     disabled_extensions_.erase(iter);
     NotificationService::current()->Notify(
         NotificationType::EXTENSION_UNLOADED_DISABLED,
-        Source<ExtensionsService>(this),
+        Source<Profile>(profile_),
         Details<Extension>(extension.get()));
     return;
   }
 
   iter = std::find(extensions_.begin(), extensions_.end(), extension.get());
 
   // Remove the extension from our list.
   extensions_.erase(iter);
 
   NotifyExtensionUnloaded(extension.get());
@@ skipping 25 matching lines @@
           installed.extensions()));
 }
 
 void ExtensionsService::OnLoadedInstalledExtensions() {
   ready_ = true;
   if (updater_.get()) {
     updater_->Start();
   }
   NotificationService::current()->Notify(
       NotificationType::EXTENSIONS_READY,
-      Source<ExtensionsService>(this),
+      Source<Profile>(profile_),
       NotificationService::NoDetails());
 }
 
 void ExtensionsService::OnExtensionLoaded(Extension* extension,
                                           bool allow_privilege_increase) {
   // Ensure extension is deleted unless we transfer ownership.
   scoped_ptr<Extension> scoped_extension(extension);
 
   if (extensions_enabled() ||
       extension->IsTheme() ||
@@ skipping 10 matching lines @@
         // then load the new one.
         UnloadExtension(old->id());
         old = NULL;
 
         if (!allow_silent_upgrade) {
           // Extension has changed permissions significantly. Disable it and
           // notify the user.
           extension_prefs_->SetExtensionState(extension, Extension::DISABLED);
           NotificationService::current()->Notify(
               NotificationType::EXTENSION_UPDATE_DISABLED,
-              Source<ExtensionsService>(this),
+              Source<Profile>(profile_),
               Details<Extension>(extension));
         }
       } else {
         // We already have the extension of the same or older version.
         std::string error_message("Duplicate extension load attempt: ");
         error_message += extension->id();
         LOG(WARNING) << error_message;
         ReportExtensionLoadError(extension->path(),
                                  error_message,
                                  NotificationType::EXTENSION_OVERINSTALL_ERROR,
@@ skipping 13 matching lines @@
         }
 
         if (extension->location() != Extension::LOAD)
           extension_prefs_->MigrateToPrefs(extension);
 
         NotifyExtensionLoaded(extension);
 
         if (extension->IsTheme() && extension->location() == Extension::LOAD) {
           NotificationService::current()->Notify(
               NotificationType::THEME_INSTALLED,
-              Source<ExtensionsService>(this),
+              Source<Profile>(profile_),
               Details<Extension>(extension));
         } else {
           ExtensionDOMUI::RegisterChromeURLOverrides(profile_,
               extension->GetChromeURLOverrides());
         }
         break;
       case Extension::DISABLED:
         NotificationService::current()->Notify(
             NotificationType::EXTENSION_UPDATE_DISABLED,
-            Source<ExtensionsService>(this),
+            Source<Profile>(profile_),
             Details<Extension>(extension));
         disabled_extensions_.push_back(scoped_extension.release());
         break;
       default:
         NOTREACHED();
         break;
     }
   }
 }
 
 void ExtensionsService::OnExtensionInstalled(Extension* extension,
                                              bool allow_privilege_increase) {
   extension_prefs_->OnExtensionInstalled(extension);
 
   // If the extension is a theme, tell the profile (and therefore ThemeProvider)
   // to apply it.
   if (extension->IsTheme()) {
     NotificationService::current()->Notify(
         NotificationType::THEME_INSTALLED,
-        Source<ExtensionsService>(this),
+        Source<Profile>(profile_),
         Details<Extension>(extension));
   } else {
     NotificationService::current()->Notify(
         NotificationType::EXTENSION_INSTALLED,
-        Source<ExtensionsService>(this),
+        Source<Profile>(profile_),
         Details<Extension>(extension));
   }
 
   // Also load the extension.
   OnExtensionLoaded(extension, allow_privilege_increase);
 }
 
 void ExtensionsService::OnExtensionOverinstallAttempted(const std::string& id) {
   Extension* extension = GetExtensionById(id);
   if (extension && extension->IsTheme()) {
     NotificationService::current()->Notify(
         NotificationType::THEME_INSTALLED,
-        Source<ExtensionsService>(this),
+        Source<Profile>(profile_),
         Details<Extension>(extension));
   } else {
     NotificationService::current()->Notify(
       NotificationType::NO_THEME_DETECTED,
-      Source<ExtensionsService>(this),
+      Source<Profile>(profile_),
       NotificationService::NoDetails());
   }
 }
 
 Extension* ExtensionsService::GetExtensionByIdInternal(const std::string& id,
                                                        bool include_enabled,
                                                        bool include_disabled) {
   std::string lowercase_id = StringToLowerASCII(id);
   if (include_enabled) {
     for (ExtensionList::const_iterator iter = extensions_.begin();
@@ skipping 64 matching lines @@
                       NULL);  // no client (silent install)
 }
 
 void ExtensionsService::ReportExtensionLoadError(
     const FilePath& extension_path,
     const std::string &error,
     NotificationType type,
     bool be_noisy) {
   NotificationService* service = NotificationService::current();
   service->Notify(type,
-                  Source<ExtensionsService>(this),
+                  Source<Profile>(profile_),
                   Details<const std::string>(&error));
 
   // TODO(port): note that this isn't guaranteed to work properly on Linux.
   std::string path_str = WideToASCII(extension_path.ToWStringHack());
   std::string message = StringPrintf("Could not load extension from '%s'. %s",
                                      path_str.c_str(), error.c_str());
   ExtensionErrorReporter::GetInstance()->ReportError(message, be_noisy);
 }
 
+std::vector<FilePath> ExtensionsService::GetPersistentBlacklistPaths() {
+  std::vector<FilePath> result;
+  for (ExtensionList::const_iterator extension_iter = extensions()->begin();
+       extension_iter != extensions()->end(); ++extension_iter) {
+    if ((*extension_iter)->location() == Extension::LOAD)
+      continue;
+
+    std::vector<Extension::PrivacyBlacklistInfo> blacklists(
+        (*extension_iter)->privacy_blacklists());
+    std::vector<Extension::PrivacyBlacklistInfo>::const_iterator blacklist_iter;
+    for (blacklist_iter = blacklists.begin();
+         blacklist_iter != blacklists.end(); ++blacklist_iter) {
+      result.push_back(blacklist_iter->path);
+    }
+  }
+  return result;
+}
+
+std::vector<FilePath> ExtensionsService::GetTransientBlacklistPaths() {
+  std::vector<FilePath> result;
+  for (ExtensionList::const_iterator extension_iter = extensions()->begin();
+       extension_iter != extensions()->end(); ++extension_iter) {
+    if ((*extension_iter)->location() != Extension::LOAD)
+      continue;
+
+    std::vector<Extension::PrivacyBlacklistInfo> blacklists(
+        (*extension_iter)->privacy_blacklists());
+    std::vector<Extension::PrivacyBlacklistInfo>::const_iterator blacklist_iter;
+    for (blacklist_iter = blacklists.begin();
+         blacklist_iter != blacklists.end(); ++blacklist_iter) {
+      result.push_back(blacklist_iter->path);
+    }
+  }
+  return result;
+}
+
 // ExtensionsServicesBackend
 
 ExtensionsServiceBackend::ExtensionsServiceBackend(
     const FilePath& install_directory)
         : frontend_(NULL),
           install_directory_(install_directory),
           alert_on_error_(false) {
   // TODO(aa): This ends up doing blocking IO on the UI thread because it reads
   // pref data in the ctor and that is called on the UI thread. Would be better
   // to re-read data each time we list external extensions, anyway.
@@ skipping 134 matching lines @@
 
 void ExtensionsServiceBackend::OnExternalExtensionFound(
     const std::string& id, const Version* version, const FilePath& path,
     Extension::Location location) {
   ChromeThread::PostTask(
       ChromeThread::UI, FROM_HERE,
       NewRunnableMethod(
           frontend_, &ExtensionsService::OnExternalExtensionFound, id,
           version->GetString(), path, location));
 }