Implement sideload wipeout for Extensions.

chrome/browser/extensions/extension_service.cc

 // Copyright (c) 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/extension_service.h"
 
 #include <algorithm>
 #include <set>
 
 #include "base/basictypes.h"
@@ skipping 120 matching lines @@
 
 using content::BrowserContext;
 using content::BrowserThread;
 using content::DevToolsAgentHost;
 using content::DevToolsAgentHostRegistry;
 using content::PluginService;
 using extensions::CrxInstaller;
 using extensions::Extension;
 using extensions::ExtensionIdSet;
 using extensions::ExtensionInfo;
+using extensions::FeatureSwitch;
 using extensions::UnloadedExtensionInfo;
 using extensions::PermissionMessage;
 using extensions::PermissionMessages;
 using extensions::PermissionSet;
 
 namespace errors = extension_manifest_errors;
 
 namespace {
 
 #if defined(OS_LINUX)
@@ skipping 283 matching lines @@
 }
 
 const ExtensionSet* ExtensionService::GenerateInstalledExtensionsSet() const {
   ExtensionSet* installed_extensions = new ExtensionSet();
   installed_extensions->InsertAll(extensions_);
   installed_extensions->InsertAll(disabled_extensions_);
   installed_extensions->InsertAll(terminated_extensions_);
   return installed_extensions;
 }
 
+const ExtensionSet* ExtensionService::GetWipedOutExtensions() const {
+  ExtensionSet* extension_set = new ExtensionSet();
+  for (ExtensionSet::const_iterator iter = disabled_extensions_.begin();
+       iter != disabled_extensions_.end(); ++iter) {
+    int disabled_reason = extension_prefs_->GetDisableReasons((*iter)->id());
+    if ((disabled_reason & Extension::DISABLE_SIDELOAD_WIPEOUT) != 0)
+      extension_set->Insert(*iter);
+  }
+  return extension_set;
+}
+
 extensions::PendingExtensionManager*
     ExtensionService::pending_extension_manager() {
   return &pending_extension_manager_;
 }
 
 ExtensionService::~ExtensionService() {
   // No need to unload extensions here because they are profile-scoped, and the
   // profile is in the process of being deleted.
 
   extensions::ProviderCollection::const_iterator i;
@@ skipping 101 matching lines @@
 
 void ExtensionService::Init() {
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   DCHECK(!ready_);  // Can't redo init.
   DCHECK_EQ(extensions_.size(), 0u);
 
   component_loader_->LoadAll();
   extensions::InstalledLoader(this).LoadAllExtensions();
 
+  // The Sideload Wipeout effort takes place during load (see above), so once
+  // that is done the flag can be set so that we don't have to check again.
+  if (FeatureSwitch::sideload_wipeout()->IsEnabled())
+    extension_prefs_->SetSideloadWipeoutDone();
+
   // If we are running in the import process, don't bother initializing the
   // extension service since this can interfere with the main browser process
   // that is already running an extension service for this profile.
   // TODO(aa): can we start up even less of ExtensionService?
   // http://crbug.com/107636
   if (!CommandLine::ForCurrentProcess()->HasSwitch(switches::kImport) &&
       !CommandLine::ForCurrentProcess()->HasSwitch(switches::kImportFromFile)) {
     if (g_browser_process->profile_manager() &&
         g_browser_process->profile_manager()->will_import()) {
       RegisterForImportFinished();
@@ skipping 1417 matching lines @@
   UntrackTerminatedExtension(extension->id());
 
   // If the extension was disabled for a reload, then enable it.
   if (disabled_extension_paths_.erase(extension->id()) > 0)
     EnableExtension(extension->id());
 
   // Check if the extension's privileges have changed and disable the
   // extension if necessary.
   InitializePermissions(extension);
 
+  // If this extension is a sideloaded extension and we've not performed a
+  // wipeout before, we might disable this extension here.
+  MaybeWipeout(extension);
+
   if (extension_prefs_->IsExtensionDisabled(extension->id())) {
     disabled_extensions_.Insert(scoped_extension);
     SyncExtensionChangeIfNeeded(*extension);
     content::NotificationService::current()->Notify(
         chrome::NOTIFICATION_EXTENSION_UPDATE_DISABLED,
         content::Source<Profile>(profile_),
         content::Details<const Extension>(extension));
 
     if (extension_prefs_->GetDisableReasons(extension->id()) &
         Extension::DISABLE_PERMISSIONS_INCREASE) {
@@ skipping 144 matching lines @@
           extension, "Extensions.Permissions_AutoDisable");
     }
     extension_prefs_->SetExtensionState(extension->id(), Extension::DISABLED);
     extension_prefs_->SetDidExtensionEscalatePermissions(extension, true);
     extension_prefs_->AddDisableReason(
         extension->id(),
         static_cast<Extension::DisableReason>(disable_reasons));
   }
 }
 
+void ExtensionService::MaybeWipeout(
+    const extensions::Extension* extension) {
+  if (!FeatureSwitch::sideload_wipeout()->IsEnabled())
+    return;
+
+  bool done = extension_prefs_->GetSideloadWipeoutDone();
+  if (done)
+    return;
+
+  int disable_reasons = extension_prefs_->GetDisableReasons(extension->id());
+  if (disable_reasons == Extension::DISABLE_NONE) {
+    Extension::Location location = extension->location();
+    if (location == Extension::EXTERNAL_REGISTRY ||
+        (location == Extension::INTERNAL && !extension->from_webstore())) {
+      extension_prefs_->SetExtensionState(extension->id(), Extension::DISABLED);
+      extension_prefs_->AddDisableReason(
+          extension->id(),
+          static_cast<Extension::DisableReason>(
+          Extension::DISABLE_SIDELOAD_WIPEOUT));
+    }
+  }
+}
+
 void ExtensionService::UpdateActiveExtensionsInCrashReporter() {
   std::set<std::string> extension_ids;
   for (ExtensionSet::const_iterator iter = extensions_.begin();
        iter != extensions_.end(); ++iter) {
     const Extension* extension = *iter;
     if (!extension->is_theme() && extension->location() != Extension::COMPONENT)
       extension_ids.insert(extension->id());
   }
 
   child_process_logging::SetActiveExtensions(extension_ids);
@@ skipping 567 matching lines @@
     // enabling them.
     if (Extension::IsExternalLocation(extension->location()) &&
         !extension_prefs_->IsExternalExtensionAcknowledged(extension->id())) {
       return false;
     }
   }
 #endif
 
   return true;
 }