Introduce an extension parameter which is used to customize the extension. It's available for exter…

chrome/browser/extensions/pending_extension_manager.cc

 // Copyright 2014 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/pending_extension_manager.h"
 
 #include <algorithm>
 
 #include "base/logging.h"
 #include "base/version.h"
@@ skipping 91 matching lines @@
   // should already be installed on every instance.
   if (id == extension_misc::kWebStoreAppId) {
     NOTREACHED();
     return false;
   }
 
   const bool kIsFromSync = true;
   const Manifest::Location kSyncLocation = Manifest::INTERNAL;
   const bool kMarkAcknowledged = false;
 
-  return AddExtensionImpl(id, update_url, Version(), should_allow_install,
-                          kIsFromSync, install_silently, kSyncLocation,
-                          Extension::NO_FLAGS, kMarkAcknowledged);
+  return AddExtensionImpl(id,
+                          std::string(),
+                          update_url,
+                          Version(),
+                          should_allow_install,
+                          kIsFromSync,
+                          install_silently,
+                          kSyncLocation,
+                          Extension::NO_FLAGS,
+                          kMarkAcknowledged);
 }
 
 bool PendingExtensionManager::AddFromExtensionImport(
     const std::string& id,
     const GURL& update_url,
     PendingExtensionInfo::ShouldAllowInstallPredicate should_allow_install) {
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   if (service_.GetInstalledExtension(id)) {
     LOG(ERROR) << "Trying to add pending extension " << id
                << " which already exists";
     return false;
   }
 
   const bool kIsFromSync = false;
   const bool kInstallSilently = true;
   const Manifest::Location kManifestLocation = Manifest::INTERNAL;
   const bool kMarkAcknowledged = false;
 
-  return AddExtensionImpl(id, update_url, Version(), should_allow_install,
-                          kIsFromSync, kInstallSilently, kManifestLocation,
-                          Extension::NO_FLAGS, kMarkAcknowledged);
+  return AddExtensionImpl(id,
+                          std::string(),
+                          update_url,
+                          Version(),
+                          should_allow_install,
+                          kIsFromSync,
+                          kInstallSilently,
+                          kManifestLocation,
+                          Extension::NO_FLAGS,
+                          kMarkAcknowledged);
 }
 
 bool PendingExtensionManager::AddFromExternalUpdateUrl(
     const std::string& id,
+    const std::string& install_parameter,
     const GURL& update_url,
     Manifest::Location location,
     int creation_flags,
     bool mark_acknowledged) {
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   const bool kIsFromSync = false;
   const bool kInstallSilently = true;
 
   const Extension* extension = service_.GetInstalledExtension(id);
-  if (extension &&
-      location == Manifest::GetHigherPriorityLocation(location,
-                                                       extension->location())) {
+  if (extension && location == Manifest::GetHigherPriorityLocation(
+                                   location, extension->location())) {
     // If the new location has higher priority than the location of an existing
     // extension, let the update process overwrite the existing extension.
   } else {
     if (service_.IsExternalExtensionUninstalled(id))
       return false;
 
     if (extension) {
       LOG(DFATAL) << "Trying to add extension " << id
                   << " by external update, but it is already installed.";
       return false;
     }
   }
 
-  return AddExtensionImpl(id, update_url, Version(), &AlwaysInstall,
-                          kIsFromSync, kInstallSilently,
-                          location, creation_flags, mark_acknowledged);
+  return AddExtensionImpl(id,
+                          install_parameter,
+                          update_url,
+                          Version(),
+                          &AlwaysInstall,
+                          kIsFromSync,
+                          kInstallSilently,
+                          location,
+                          creation_flags,
+                          mark_acknowledged);
 }
 
 
 bool PendingExtensionManager::AddFromExternalFile(
     const std::string& id,
     Manifest::Location install_source,
     const Version& version,
     int creation_flags,
     bool mark_acknowledged) {
   // TODO(skerner): AddFromSync() checks to see if the extension is
   // installed, but this method assumes that the caller already
   // made sure it is not installed.  Make all AddFrom*() methods
   // consistent.
   GURL kUpdateUrl = GURL();
   bool kIsFromSync = false;
   bool kInstallSilently = true;
 
-  return AddExtensionImpl(
-      id,
-      kUpdateUrl,
-      version,
-      &AlwaysInstall,
-      kIsFromSync,
-      kInstallSilently,
-      install_source,
-      creation_flags,
-      mark_acknowledged);
+  return AddExtensionImpl(id,
+                          std::string(),
+                          kUpdateUrl,
+                          version,
+                          &AlwaysInstall,
+                          kIsFromSync,
+                          kInstallSilently,
+                          install_source,
+                          creation_flags,
+                          mark_acknowledged);
 }
 
 void PendingExtensionManager::GetPendingIdsForUpdateCheck(
     std::list<std::string>* out_ids_for_update_check) const {
   PendingExtensionList::const_iterator iter;
   for (iter = pending_extension_list_.begin();
        iter != pending_extension_list_.end();
        ++iter) {
     Manifest::Location install_source = iter->install_source();
 
     // Some install sources read a CRX from the filesystem.  They can
     // not be fetched from an update URL, so don't include them in the
     // set of ids.
     if (install_source == Manifest::EXTERNAL_PREF ||
         install_source == Manifest::EXTERNAL_REGISTRY)
       continue;
 
     out_ids_for_update_check->push_back(iter->id());
   }
 }
 
 bool PendingExtensionManager::AddExtensionImpl(
     const std::string& id,
+    const std::string& install_parameter,
     const GURL& update_url,
     const Version& version,
     PendingExtensionInfo::ShouldAllowInstallPredicate should_allow_install,
     bool is_from_sync,
     bool install_silently,
     Manifest::Location install_source,
     int creation_flags,
     bool mark_acknowledged) {
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   PendingExtensionInfo info(id,
+                            install_parameter,
                             update_url,
                             version,
                             should_allow_install,
                             is_from_sync,
                             install_silently,
                             install_source,
                             creation_flags,
                             mark_acknowledged);
 
   if (const PendingExtensionInfo* pending = GetById(id)) {
@@ skipping 30 matching lines @@
 
   return true;
 }
 
 void PendingExtensionManager::AddForTesting(
     const PendingExtensionInfo& pending_extension_info) {
   pending_extension_list_.push_back(pending_extension_info);
 }
 
 }  // namespace extensions