Perform install tasks for newly installed or upgraded component apps/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 2082 matching lines @@
     extension_prefs_->extension_sorting()->EnsureValidOrdinals(
         extension->id(), syncer::StringOrdinal());
   }
 
   extensions_.Insert(scoped_extension);
   SyncExtensionChangeIfNeeded(*extension);
   NotifyExtensionLoaded(extension);
   DoPostLoadTasks(extension);
 }
 
+void ExtensionService::AddComponentExtension(const Extension* extension) {
+  const Version old_version(
+      extension_prefs_->GetVersionString(extension->id()));
+
+  if (!old_version.IsValid() || !old_version.Equals(*extension->version())) {
+    VLOG(1) << "Component extension " << extension->name() << " ("
+        << extension->id() << ") installing/upgrading from "
+        << (old_version.IsValid() ? old_version.GetString() : "<none>")

[Yoyo Zhou, 2012/11/27 23:54:18]

GetVersionString gives you a string; you might as well use that here.

[tapted, 2012/11/28 06:21:14]

Done. (I think that's what you had in mind).

+        << " to " << extension->version()->GetString();
+
+    AddNewOrUpdatedExtension(extension,
+                             syncer::StringOrdinal(),
+                             Extension::ENABLED_COMPONENT);
+    return;
+  }
+
+  AddExtension(extension);
+}
+
 void ExtensionService::InitializePermissions(const Extension* extension) {
   // If the extension has used the optional permissions API, it will have a
   // custom set of active permissions defined in the extension prefs. Here,
   // we update the extension's active permissions based on the prefs.
   scoped_refptr<PermissionSet> active_permissions =
       extension_prefs()->GetActivePermissions(extension->id());
 
   if (active_permissions.get()) {
     // We restrict the active permissions to be within the bounds defined in the
     // extension's manifest.
@@ skipping 255 matching lines @@
 
     // Transfer ownership of |extension|.
     pending_extension_updates_.Insert(scoped_extension);
 
     // Notify extension of available update.
     extensions::RuntimeEventRouter::DispatchOnUpdateAvailableEvent(
         profile_, id, extension->manifest()->value());
     return;
   }
 
+  // Transfer ownership of |extension|.
+  AddNewOrUpdatedExtension(
+      scoped_extension,
+      page_ordinal,
+      initial_enable ? Extension::ENABLED : Extension::DISABLED);
+}
+
+void ExtensionService::AddNewOrUpdatedExtension(
+    const Extension* extension,
+    const syncer::StringOrdinal& page_ordinal,
+    Extension::State initial_state) {
+  CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+
   extension_prefs_->OnExtensionInstalled(
       extension,
-      initial_enable ? Extension::ENABLED : Extension::DISABLED,
+      initial_state,
       page_ordinal);
 
   // Unpacked extensions default to allowing file access, but if that has been
   // overridden, don't reset the value.
   if (Extension::ShouldAlwaysAllowFileAccess(extension->location()) &&
-      !extension_prefs_->HasAllowFileAccessSetting(id)) {
-    extension_prefs_->SetAllowFileAccess(id, true);
+      !extension_prefs_->HasAllowFileAccessSetting(extension->id())) {
+    extension_prefs_->SetAllowFileAccess(extension->id(), true);
   }
 
   content::NotificationService::current()->Notify(
       chrome::NOTIFICATION_EXTENSION_INSTALLED,
       content::Source<Profile>(profile_),
       content::Details<const Extension>(extension));
 
   bool unacknowledged_external = IsUnacknowledgedExternalExtension(extension);
 
   // Transfer ownership of |extension| to AddExtension.
-  AddExtension(scoped_extension);
+  AddExtension(extension);
 
   // If this is a new external extension that was disabled, alert the user
   // so he can reenable it. We do this last so that it has already been
   // added to our list of extensions.
   if (unacknowledged_external) {
     UpdateExternalExtensionAlert();
     UMA_HISTOGRAM_ENUMERATION("Extensions.ExternalExtensionEvent",
                               EXTERNAL_EXTENSION_INSTALLED,
                               EXTERNAL_EXTENSION_BUCKET_BOUNDARY);
   }
@@ skipping 561 matching lines @@
   ExtensionProcessManager* process_manager = system_->process_manager();
   DCHECK(process_manager);
   extensions::ExtensionHost* host =
       process_manager->GetBackgroundHostForExtension(extension_id);
   return !host;
 }
 
 void ExtensionService::OnBlacklistUpdated() {
   CheckManagementPolicy();
 }