Change extension unload notification to indicate updates....

chrome/browser/extensions/extension_service.cc

 // Copyright (c) 2010 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 "base/basictypes.h"
 #include "base/command_line.h"
@@ skipping 875 matching lines @@
 
   // Also copy the extension identifier since the reference might have been
   // obtained via Extension::id().
   std::string extension_id_copy(extension_id);
 
   if (profile_->GetTemplateURLModel())
     profile_->GetTemplateURLModel()->UnregisterExtensionKeyword(extension);
 
   // Unload before doing more cleanup to ensure that nothing is hanging on to
   // any of these resources.
-  UnloadExtension(extension_id);
+  UnloadExtension(extension_id, UnloadedExtensionInfo::UNINSTALL);
 
   extension_prefs_->OnExtensionUninstalled(extension_id_copy, location,
                                            external_uninstall);
 
   // Tell the backend to start deleting installed extensions on the file thread.
   if (Extension::LOAD != location) {
     BrowserThread::PostTask(
       BrowserThread::FILE, FROM_HERE,
       NewRunnableFunction(
           &extension_file_util::UninstallExtension,
@@ skipping 57 matching lines @@
   // Move it over to the disabled list.
   disabled_extensions_.push_back(make_scoped_refptr(extension));
   ExtensionList::iterator iter = std::find(extensions_.begin(),
                                            extensions_.end(),
                                            extension);
   extensions_.erase(iter);
 
   ExtensionDOMUI::UnregisterChromeURLOverrides(profile_,
       extension->GetChromeURLOverrides());
 
-  NotifyExtensionUnloaded(extension);
+  NotifyExtensionUnloaded(extension, UnloadedExtensionInfo::DISABLE);
   UpdateActiveExtensionsInCrashReporter();
 }
 
 void ExtensionService::GrantPermissions(const Extension* extension) {
   CHECK(extension);
 
   // We only maintain the granted permissions prefs for INTERNAL extensions.
   CHECK(extension->location() == Extension::INTERNAL);
 
   ExtensionExtent effective_hosts = extension->GetEffectiveHostPermissions();
@@ skipping 246 matching lines @@
     if (extension->is_app())
       GrantProtectedStorage(extension);
   }
 
   NotificationService::current()->Notify(
       NotificationType::EXTENSION_LOADED,
       Source<Profile>(profile_),
       Details<const Extension>(extension));
 }
 
-void ExtensionService::NotifyExtensionUnloaded(const Extension* extension) {
+void ExtensionService::NotifyExtensionUnloaded(
+    const Extension* extension, UnloadedExtensionInfo::Reason reason) {
+  UnloadedExtensionInfo details(extension, reason);
   NotificationService::current()->Notify(
       NotificationType::EXTENSION_UNLOADED,
       Source<Profile>(profile_),
-      Details<const Extension>(extension));
+      Details<UnloadedExtensionInfo>(&details));
 
   if (profile_) {
     profile_->UnregisterExtensionWithRequestContexts(extension);
 
     // Check if this permission required unlimited storage quota, reset its
     // in-memory quota.
     if (extension->HasApiPermission(Extension::kUnlimitedStoragePermission))
       RevokeUnlimitedStorage(extension);
 
     // If this is an app, then stop protecting its storage so it can be deleted.
@@ skipping 109 matching lines @@
        iter != extensions_.end(); ++iter) {
     const Extension* extension = (*iter);
     if (blacklist_set.find(extension->id()) != blacklist_set.end()) {
       to_be_removed.push_back(extension->id());
     }
   }
 
   // UnloadExtension will change the extensions_ list. So, we should
   // call it outside the iterator loop.
   for (unsigned int i = 0; i < to_be_removed.size(); ++i) {
-    UnloadExtension(to_be_removed[i]);
+    UnloadExtension(to_be_removed[i], UnloadedExtensionInfo::DISABLE);
   }
 }
 
 void ExtensionService::DestroyingProfile() {
   pref_change_registrar_.RemoveAll();
   profile_ = NULL;
   toolbar_model_.DestroyingProfile();
 }
 
 ExtensionPrefs* ExtensionService::extension_prefs() {
   return extension_prefs_;
 }
 
 void ExtensionService::CheckAdminBlacklist() {
   std::vector<std::string> to_be_removed;
   // Loop through extensions list, unload installed extensions.
   for (ExtensionList::const_iterator iter = extensions_.begin();
        iter != extensions_.end(); ++iter) {
     const Extension* extension = (*iter);
     if (!extension_prefs_->IsExtensionAllowedByPolicy(extension->id()))
       to_be_removed.push_back(extension->id());
   }
 
   // UnloadExtension will change the extensions_ list. So, we should
   // call it outside the iterator loop.
   for (unsigned int i = 0; i < to_be_removed.size(); ++i)
-    UnloadExtension(to_be_removed[i]);
+    UnloadExtension(to_be_removed[i], UnloadedExtensionInfo::DISABLE);
 }
 
 bool ExtensionService::IsIncognitoEnabled(const Extension* extension) {
   // If this is a component extension we always allow it to work in incognito
   // mode.
   if (extension->location() == Extension::COMPONENT)
     return true;
 
   // Check the prefs.
   return extension_prefs_->IsIncognitoEnabled(extension->id());
 }
 
 void ExtensionService::SetIsIncognitoEnabled(const Extension* extension,
                                               bool enabled) {
   extension_prefs_->SetIsIncognitoEnabled(extension->id(), enabled);
 
   // Broadcast unloaded and loaded events to update browser state. Only bother
   // if the extension is actually enabled, since there is no UI otherwise.
   bool is_enabled = std::find(extensions_.begin(), extensions_.end(),
                               extension) != extensions_.end();
   if (is_enabled) {
-    NotifyExtensionUnloaded(extension);
+    NotifyExtensionUnloaded(extension, UnloadedExtensionInfo::DISABLE);
     NotifyExtensionLoaded(extension);
   }
 }
 
 bool ExtensionService::CanCrossIncognito(const Extension* extension) {
   // We allow the extension to see events and data from another profile iff it
   // uses "spanning" behavior and it has incognito access. "split" mode
   // extensions only see events for a matching profile.
   return IsIncognitoEnabled(extension) && !extension->incognito_split_mode();
 }
@@ skipping 38 matching lines @@
     list_copy = static_cast<ListValue*>(list_pref->DeepCopy());
   BrowserThread::PostTask(
       BrowserThread::FILE, FROM_HERE,
       NewRunnableMethod(
           backend_.get(),
           &ExtensionServiceBackend::UpdateExternalPolicyExtensionProvider,
           scoped_refptr<RefCountedList>(
               new RefCountedList(list_copy))));
 }
 
-void ExtensionService::UnloadExtension(const std::string& extension_id) {
+void ExtensionService::UnloadExtension(
+    const std::string& extension_id,
+    UnloadedExtensionInfo::Reason reason) {
   // Make sure the extension gets deleted after we return from this function.
   scoped_refptr<const Extension> extension(
       GetExtensionByIdInternal(extension_id, true, true));
 
   // This method can be called via PostTask, so the extension may have been
   // unloaded by the time this runs.
   if (!extension)
     return;
 
   // Keep information about the extension so that we can reload it later
   // even if it's not permanently installed.
   unloaded_extension_paths_[extension->id()] = extension->path();
 
   // Clean up if the extension is meant to be enabled after a reload.
   disabled_extension_paths_.erase(extension->id());
 
   // Clean up runtime data.
   extension_runtime_data_.erase(extension_id);
 
   ExtensionDOMUI::UnregisterChromeURLOverrides(profile_,
       extension->GetChromeURLOverrides());
 
   ExtensionList::iterator iter = std::find(disabled_extensions_.begin(),
                                            disabled_extensions_.end(),
                                            extension.get());
   if (iter != disabled_extensions_.end()) {
+    UnloadedExtensionInfo details(extension, reason);
+    details.already_disabled = true;
     disabled_extensions_.erase(iter);
     NotificationService::current()->Notify(
-        NotificationType::EXTENSION_UNLOADED_DISABLED,
+        NotificationType::EXTENSION_UNLOADED,
         Source<Profile>(profile_),
-        Details<const Extension>(extension.get()));
+        Details<UnloadedExtensionInfo>(&details));
     return;
   }
 
   iter = std::find(extensions_.begin(), extensions_.end(), extension.get());
 
   // Remove the extension from our list.
   extensions_.erase(iter);
 
-  NotifyExtensionUnloaded(extension.get());
+  NotifyExtensionUnloaded(extension.get(), reason);
   UpdateActiveExtensionsInCrashReporter();
 }
 
 void ExtensionService::UnloadAllExtensions() {
   extensions_.clear();
   disabled_extensions_.clear();
   extension_runtime_data_.clear();
 
   // TODO(erikkay) should there be a notification for this?  We can't use
   // EXTENSION_UNLOADED since that implies that the extension has been disabled
@@ skipping 165 matching lines @@
 
     // Extensions get upgraded if the privileges are allowed to increase or
     // the privileges haven't increased.
     if (!is_privilege_increase) {
       SetBeingUpgraded(old, true);
       SetBeingUpgraded(extension, true);
     }
 
     // To upgrade an extension in place, unload the old one and
     // then load the new one.
-    UnloadExtension(old->id());
+    UnloadExtension(old->id(), UnloadedExtensionInfo::UPDATE);
     old = NULL;
   }
 
   // Extension has changed permissions significantly. Disable it. A
   // notification should be sent by the caller.
   if (is_privilege_increase) {
     extension_prefs_->SetExtensionState(extension, Extension::DISABLED);
     extension_prefs_->SetDidExtensionEscalatePermissions(extension, true);
   }
 }
@@ skipping 269 matching lines @@
       if (profile_ != Source<Profile>(source).ptr()->GetOriginalProfile())
         break;
 
       ExtensionHost* host = Details<ExtensionHost>(details).ptr();
 
       // Unload the entire extension. We want it to be in a consistent state:
       // either fully working or not loaded at all, but never half-crashed.
       // We do it in a PostTask so that other handlers of this notification will
       // still have access to the Extension and ExtensionHost.
       MessageLoop::current()->PostTask(FROM_HERE,
-          NewRunnableMethod(this, &ExtensionService::UnloadExtension,
-                            host->extension()->id()));
+          NewRunnableMethod(this,
+                            &ExtensionService::UnloadExtension,
+                            host->extension()->id(),
+                            UnloadedExtensionInfo::DISABLE));
       break;
     }
 
     case NotificationType::PREF_CHANGED: {
       std::string* pref_name = Details<std::string>(details).ptr();
       if (*pref_name == prefs::kExtensionInstallAllowList ||
           *pref_name == prefs::kExtensionInstallDenyList) {
         CheckAdminBlacklist();
       } else if (*pref_name == prefs::kExtensionInstallForceList) {
         UpdateExternalPolicyExtensionProvider();
@@ skipping 46 matching lines @@
 }
 
 void ExtensionService::SetBeingUpgraded(const Extension* extension,
                                          bool value) {
   extension_runtime_data_[extension->id()].being_upgraded = value;
 }
 
 PropertyBag* ExtensionService::GetPropertyBag(const Extension* extension) {
   return &extension_runtime_data_[extension->id()].property_bag;
 }