Move ExtensionService::GetExtensionById() to ExtensionRegistry

chrome/browser/extensions/extension_service.cc

 // Copyright (c) 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 "chrome/browser/extensions/extension_service.h"
 
 #include <algorithm>
 #include <iterator>
 #include <set>
 
@@ skipping 97 matching lines @@
 #include "webkit/browser/fileapi/file_system_context.h"
 #endif
 
 using content::BrowserContext;
 using content::BrowserThread;
 using content::DevToolsAgentHost;
 using extensions::CrxInstaller;
 using extensions::Extension;
 using extensions::ExtensionIdSet;
 using extensions::ExtensionInfo;
+using extensions::ExtensionRegistry;
 using extensions::ExtensionSet;
 using extensions::FeatureSwitch;
 using extensions::InstallVerifier;
 using extensions::ManagementPolicy;
 using extensions::Manifest;
 using extensions::PermissionMessage;
 using extensions::PermissionMessages;
 using extensions::PermissionSet;
 using extensions::SharedModuleInfo;
 using extensions::UnloadedExtensionInfo;
@@ skipping 325 matching lines @@
   }
 }
 
 void ExtensionService::Shutdown() {
   system_->management_policy()->UnregisterProvider(
       shared_module_policy_provider_.get());
 }
 
 const Extension* ExtensionService::GetExtensionById(
     const std::string& id, bool include_disabled) const {
-  int include_mask = INCLUDE_ENABLED;
+  int include_mask = ExtensionRegistry::INCLUDE_ENABLED;
   if (include_disabled) {
     // Include blacklisted extensions here because there are hundreds of
     // callers of this function, and many might assume that this includes those
     // that have been disabled due to blacklisting.
-    include_mask |= INCLUDE_DISABLED | INCLUDE_BLACKLISTED;
+    include_mask |= ExtensionRegistry::INCLUDE_DISABLED |
+                    ExtensionRegistry::INCLUDE_BLACKLISTED;
   }
-  return GetExtensionById(id, include_mask);
+  return registry_->GetExtensionById(id, include_mask);
 }
 
 GURL ExtensionService::GetSiteForExtensionId(const std::string& extension_id) {
   return content::SiteInstance::GetSiteForURL(
       profile_,
       Extension::GetBaseURLFromExtensionId(extension_id));
 }
 
-const Extension* ExtensionService::GetExtensionById(
-    const std::string& id, int include_mask) const {
-  std::string lowercase_id = StringToLowerASCII(id);
-  if (include_mask & INCLUDE_ENABLED) {
-    const Extension* extension =
-        registry_->enabled_extensions().GetByID(lowercase_id);
-    if (extension)
-      return extension;
-  }
-  if (include_mask & INCLUDE_DISABLED) {
-    const Extension* extension =
-        registry_->disabled_extensions().GetByID(lowercase_id);
-    if (extension)
-      return extension;
-  }
-  if (include_mask & INCLUDE_TERMINATED) {
-    const Extension* extension =
-        registry_->terminated_extensions().GetByID(lowercase_id);
-    if (extension)
-      return extension;
-  }
-  if (include_mask & INCLUDE_BLACKLISTED) {
-    const Extension* extension =
-        registry_->blacklisted_extensions().GetByID(lowercase_id);
-    if (extension)
-      return extension;
-  }
-  return NULL;
-}
-
 void ExtensionService::Init() {
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   base::Time begin_time = base::Time::Now();
 
   DCHECK(!is_ready());  // Can't redo init.
   DCHECK_EQ(registry_->enabled_extensions().size(), 0u);
 
   const CommandLine* cmd_line = CommandLine::ForCurrentProcess();
   if (cmd_line->HasSwitch(switches::kInstallFromWebstore) ||
@@ skipping 495 matching lines @@
   // installed yet.
   if (extension &&
       disable_reason != Extension::DISABLE_RELOAD &&
       !system_->management_policy()->UserMayModifySettings(extension, NULL)) {
     return;
   }
 
   extension_prefs_->SetExtensionState(extension_id, Extension::DISABLED);
   extension_prefs_->AddDisableReason(extension_id, disable_reason);
 
-  int include_mask = INCLUDE_EVERYTHING & ~INCLUDE_DISABLED;
-  extension = GetExtensionById(extension_id, include_mask);
+  int include_mask = ExtensionRegistry::INCLUDE_EVERYTHING &
+                     ~ExtensionRegistry::INCLUDE_DISABLED;
+  extension = registry_->GetExtensionById(extension_id, include_mask);
   if (!extension)
     return;
 
   // Reset the background_page_ready flag
   if (extensions::BackgroundInfo::HasBackgroundPage(extension))
     extension_runtime_data_[extension->id()].background_page_ready = false;
 
   // Move it over to the disabled list. Don't send a second unload notification
   // for terminated extensions being disabled.
   registry_->AddDisabled(make_scoped_refptr(extension));
@@ skipping 190 matching lines @@
   }
 #endif
 
   UpdateActiveExtensionsInCrashReporter();
 }
 
 Profile* ExtensionService::profile() {
   return profile_;
 }
 
+content::BrowserContext* ExtensionService::GetBrowserContext() const {
+  // Implemented in the .cc file to avoid adding a profile.h dependency to
+  // extension_service.h.
+  return profile_;
+}
+
 extensions::ExtensionPrefs* ExtensionService::extension_prefs() {
   return extension_prefs_;
 }
 
 const extensions::ExtensionPrefs* ExtensionService::extension_prefs() const {
   return extension_prefs_;
 }
 
 extensions::SettingsFrontend* ExtensionService::settings_frontend() {
   return settings_frontend_.get();
@@ skipping 357 matching lines @@
     }
   } else {
     extensions::RemoveExternalInstallError(this);
   }
 }
 
 void ExtensionService::UnloadExtension(
     const std::string& extension_id,
     UnloadedExtensionInfo::Reason reason) {
   // Make sure the extension gets deleted after we return from this function.
-  int include_mask = INCLUDE_EVERYTHING & ~INCLUDE_TERMINATED;
+  int include_mask = ExtensionRegistry::INCLUDE_EVERYTHING &
+                     ~ExtensionRegistry::INCLUDE_TERMINATED;
   scoped_refptr<const Extension> extension(
-      GetExtensionById(extension_id, include_mask));
+      registry_->GetExtensionById(extension_id, include_mask));
 
   // This method can be called via PostTask, so the extension may have been
   // unloaded by the time this runs.
   if (!extension.get()) {
     // In case the extension may have crashed/uninstalled. Allow the profile to
     // clean up its RequestContexts.
     system_->UnregisterExtensionWithRequestContexts(extension_id, reason);
     return;
   }
 
@@ skipping 734 matching lines @@
   if (extension) {
     content::NotificationService::current()->Notify(
         chrome::NOTIFICATION_EXTENSION_REMOVED,
         content::Source<Profile>(profile_),
         content::Details<const Extension>(extension));
   }
 }
 
 const Extension* ExtensionService::GetTerminatedExtension(
     const std::string& id) const {
-  return GetExtensionById(id, INCLUDE_TERMINATED);
+  return registry_->GetExtensionById(id, ExtensionRegistry::INCLUDE_TERMINATED);
 }
 
 const Extension* ExtensionService::GetInstalledExtension(
     const std::string& id) const {
-  int include_mask = INCLUDE_ENABLED |
-                     INCLUDE_DISABLED |
-                     INCLUDE_TERMINATED |
-                     INCLUDE_BLACKLISTED;
-  return GetExtensionById(id, include_mask);
+  return registry_->GetExtensionById(id, ExtensionRegistry::INCLUDE_EVERYTHING);
 }
 
 bool ExtensionService::ExtensionBindingsAllowed(const GURL& url) {
   // Allow bindings for all packaged extensions and component hosted apps.
   const Extension* extension =
       registry_->enabled_extensions().GetExtensionOrAppByURL(url);
   return extension && (!extension->is_hosted_app() ||
                        extension->location() == Manifest::COMPONENT);
 }
 
@@ skipping 476 matching lines @@
 void ExtensionService::UnloadAllExtensionsInternal() {
   profile_->GetExtensionSpecialStoragePolicy()->RevokeRightsForAllExtensions();
 
   registry_->ClearAll();
   extension_runtime_data_.clear();
 
   // TODO(erikkay) should there be a notification for this?  We can't use
   // EXTENSION_UNLOADED since that implies that the extension has been disabled
   // or uninstalled.
 }