Sever PendingExtensionManager's dependency on ExtensionService

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"
-#include "chrome/browser/extensions/extension_service.h"
+#include "chrome/common/extensions/extension_constants.h"
 #include "content/public/browser/browser_thread.h"
 #include "extensions/browser/extension_prefs.h"
+#include "extensions/browser/extension_registry.h"
 #include "extensions/common/extension.h"
 #include "url/gurl.h"
 
 using content::BrowserThread;
 
 namespace {
 
 // Install predicate used by AddFromExternalUpdateUrl().
 bool AlwaysInstall(const extensions::Extension* extension) {
   return true;
 }
 
 std::string GetVersionString(const Version& version) {
   return version.IsValid() ? version.GetString() : "invalid";
 }
 
 }  // namespace
 
 namespace extensions {
 
 PendingExtensionManager::PendingExtensionManager(
-    const ExtensionServiceInterface& service,
     content::BrowserContext* context)
-    : service_(service), context_(context) {}
+    : context_(context) {}
 
 PendingExtensionManager::~PendingExtensionManager() {}
 
 const PendingExtensionInfo* PendingExtensionManager::GetById(
     const std::string& id) const {
   PendingExtensionList::const_iterator iter;
   for (iter = pending_extension_list_.begin();
        iter != pending_extension_list_.end();
        ++iter) {
     if (id == iter->id())
@@ skipping 38 matching lines @@
 }
 
 bool PendingExtensionManager::AddFromSync(
     const std::string& id,
     const GURL& update_url,
     PendingExtensionInfo::ShouldAllowInstallPredicate should_allow_install,
     bool install_silently,
     bool remote_install) {
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
-  if (service_.GetInstalledExtension(id)) {
+  if (ExtensionRegistry::Get(context_)->GetExtensionById(
+          id, ExtensionRegistry::EVERYTHING)) {
     LOG(ERROR) << "Trying to add pending extension " << id
                << " which already exists";
     return false;
   }
 
   // Make sure we don't ever try to install the CWS app, because even though
   // it is listed as a syncable app (because its values need to be synced) it
   // 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;
+  static const bool kIsFromSync = true;
+  static const Manifest::Location kSyncLocation = Manifest::INTERNAL;
+  static const bool kMarkAcknowledged = false;
 
   return AddExtensionImpl(id,
                           std::string(),
                           update_url,
                           Version(),
                           should_allow_install,
                           kIsFromSync,
                           install_silently,
                           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 (service_.GetInstalledExtension(id)) {
+  if (ExtensionRegistry::Get(context_)->GetExtensionById(
+          id, ExtensionRegistry::EVERYTHING)) {
     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;
-  const bool kRemoteInstall = false;
+  static const bool kIsFromSync = false;
+  static const bool kInstallSilently = true;
+  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,
                           kInstallSilently,
                           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,
     bool mark_acknowledged) {
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
-  const bool kIsFromSync = false;
-  const bool kInstallSilently = true;
-  const bool kRemoteInstall = false;
+  static const bool kIsFromSync = false;
+  static const bool kInstallSilently = true;
+  static const bool kRemoteInstall = false;
 
-  const Extension* extension = service_.GetInstalledExtension(id);
+  const Extension* extension = ExtensionRegistry::Get(context_)
+      ->GetExtensionById(id, ExtensionRegistry::EVERYTHING);
   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 (ExtensionPrefs::Get(context_)->IsExternalExtensionUninstalled(id))
       return false;
 
     if (extension) {
       LOG(DFATAL) << "Trying to add extension " << id
@@ skipping 19 matching lines @@
 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();
-  const bool kIsFromSync = false;
-  const bool kInstallSilently = true;
-  const bool kRemoteInstall = false;
+  const GURL& kUpdateUrl = GURL::EmptyGURL();
+  static const bool kIsFromSync = false;
+  static const bool kInstallSilently = true;
+  static const bool kRemoteInstall = false;
 
   return AddExtensionImpl(id,
                           std::string(),
                           kUpdateUrl,
                           version,
                           &AlwaysInstall,
                           kIsFromSync,
                           kInstallSilently,
                           install_source,
                           creation_flags,
@@ skipping 80 matching lines @@
 
   return true;
 }
 
 void PendingExtensionManager::AddForTesting(
     const PendingExtensionInfo& pending_extension_info) {
   pending_extension_list_.push_back(pending_extension_info);
 }
 
 }  // namespace extensions