Remove ExtensionService::IsExternalExtensionUninstalled()

extensions/browser/pending_extension_manager.cc

 // Copyright 2013 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 "extensions/browser/pending_extension_manager.h"
 
 #include <algorithm>
 
 #include "base/logging.h"
 #include "base/version.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "content/public/browser/browser_thread.h"
+#include "extensions/browser/extension_prefs.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)
-    : service_(service) {
-}
+    const ExtensionServiceInterface& service,
+    content::BrowserContext* context)
+    : service_(service), 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 94 matching lines @@
     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))
+    if (ExtensionPrefs::Get(context_)->IsExternalExtensionUninstalled(id))

[Yoyo Zhou, 2014/03/18 01:23:37]

Could also use service->GetBrowserContext here.

[Devlin, 2014/03/18 17:24:12]

Actually, can't... |service_| is an ExtensionServiceInterface, which doesn't
have the GetBrowserContext method. Options:
1. Add a GetBrowserContext() to ExtensionServiceInterface (which also means
adding it to TestExtensionService).
2. Now that PendingExtensionManager is back in chrome/, it could take a real
ExtensionService.
3. Leave it like this.

Preferences?

[Yoyo Zhou, 2014/03/22 00:34:37]

May as well leave it as is for now then.

       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,
@@ skipping 103 matching lines @@
 
   return true;
 }
 
 void PendingExtensionManager::AddForTesting(
     const PendingExtensionInfo& pending_extension_info) {
   pending_extension_list_.push_back(pending_extension_info);
 }
 
 }  // namespace extensions