Adding the creation flags back to pending extension info.

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 102 matching lines @@
   static const Manifest::Location kSyncLocation = Manifest::INTERNAL;
   static const bool kMarkAcknowledged = false;
 
   return AddExtensionImpl(id,
                           std::string(),
                           update_url,
                           version,
                           should_allow_install,
                           kIsFromSync,
                           kSyncLocation,
+                          Extension::NO_FLAGS,
                           kMarkAcknowledged,
                           remote_install);
 }
 
 bool PendingExtensionManager::AddFromExtensionImport(
     const std::string& id,
     const GURL& update_url,
     PendingExtensionInfo::ShouldAllowInstallPredicate should_allow_install) {
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   if (ExtensionRegistry::Get(context_)->GetExtensionById(
           id, ExtensionRegistry::EVERYTHING)) {
     LOG(ERROR) << "Trying to add pending extension " << id
                << " which already exists";
     return false;
   }
 
   static const bool kIsFromSync = false;
   static const Manifest::Location kManifestLocation = Manifest::INTERNAL;
   static const bool kMarkAcknowledged = false;
   static const bool kRemoteInstall = false;
 
   return AddExtensionImpl(id,
                           std::string(),
                           update_url,
                           Version(),
                           should_allow_install,
                           kIsFromSync,
                           kManifestLocation,
+                          Extension::NO_FLAGS,
                           kMarkAcknowledged,
                           kRemoteInstall);
 }
 
 bool PendingExtensionManager::AddFromExternalUpdateUrl(
     const std::string& id,
     const std::string& install_parameter,
     const GURL& update_url,
     Manifest::Location location,
     int creation_flags,
@@ skipping 20 matching lines @@
     }
   }
 
   return AddExtensionImpl(id,
                           install_parameter,
                           update_url,
                           Version(),
                           &AlwaysInstall,
                           kIsFromSync,
                           location,
+                          creation_flags,
                           mark_acknowledged,
                           kRemoteInstall);
 }
 
 
 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.
   const GURL& kUpdateUrl = GURL::EmptyGURL();
   static const bool kIsFromSync = false;
   static const bool kRemoteInstall = false;
 
   return AddExtensionImpl(id,
                           std::string(),
                           kUpdateUrl,
                           version,
                           &AlwaysInstall,
                           kIsFromSync,
                           install_source,
+                          creation_flags,
                           mark_acknowledged,
                           kRemoteInstall);
 }
 
 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) {
@@ skipping 13 matching lines @@
 }
 
 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,
     Manifest::Location install_source,
+    int creation_flags,
     bool mark_acknowledged,
     bool remote_install) {
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   PendingExtensionInfo info(id,
                             install_parameter,
                             update_url,
                             version,
                             should_allow_install,
                             is_from_sync,
                             install_source,
+                            creation_flags,
                             mark_acknowledged,
                             remote_install);
 
   if (const PendingExtensionInfo* pending = GetById(id)) {
     // Bugs in this code will manifest as sporadic incorrect extension
     // locations in situations where multiple install sources run at the
     // same time. For example, on first login to a chrome os machine, an
     // extension may be requested by sync and the default extension set.
     // The following logging will help diagnose such issues.
     VLOG(1) << "Extension id " << id
@@ skipping 24 matching lines @@
 
   return true;
 }
 
 void PendingExtensionManager::AddForTesting(
     const PendingExtensionInfo& pending_extension_info) {
   pending_extension_list_.push_back(pending_extension_info);
 }
 
 }  // namespace extensions