Remove the deprecated function ExtensionService::extensions().

chrome/browser/extensions/extension_browsertest.cc

 // Copyright (c) 2012 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_browsertest.h"
 
 #include <vector>
 
 #include "base/command_line.h"
 #include "base/files/file_path.h"
@@ skipping 25 matching lines @@
 #include "chrome/common/chrome_version_info.h"
 #include "content/public/browser/navigation_controller.h"
 #include "content/public/browser/navigation_entry.h"
 #include "content/public/browser/notification_registrar.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/test/browser_test_utils.h"
 #include "content/public/test/test_utils.h"
 #include "extensions/browser/extension_host.h"
 #include "extensions/browser/extension_prefs.h"
+#include "extensions/browser/extension_registry.h"
 #include "extensions/browser/extension_system.h"
 #include "extensions/browser/notification_types.h"
 #include "extensions/browser/uninstall_reason.h"
 #include "extensions/common/constants.h"
 #include "extensions/common/extension_set.h"
 #include "sync/api/string_ordinal.h"
 
 #if defined(OS_CHROMEOS)
 #include "chromeos/chromeos_switches.h"
 #endif
 
 using extensions::Extension;
 using extensions::ExtensionCreator;
+using extensions::ExtensionRegistry;
 using extensions::FeatureSwitch;
 using extensions::Manifest;
 
 ExtensionBrowserTest::ExtensionBrowserTest()
     : loaded_(false),
       installed_(false),
 #if defined(OS_CHROMEOS)
       set_chromeos_user_(true),
 #endif
       // Default channel is STABLE but override with UNKNOWN so that unlaunched
@@ skipping 21 matching lines @@
     if (browser())
       profile_ = browser()->profile();
     else
       profile_ = ProfileManager::GetActiveUserProfile();
   }
   return profile_;
 }
 
 // static
 const Extension* ExtensionBrowserTest::GetExtensionByPath(
-    const extensions::ExtensionSet* extensions, const base::FilePath& path) {
+    const extensions::ExtensionSet& extensions,
+    const base::FilePath& path) {
   base::FilePath extension_path = base::MakeAbsoluteFilePath(path);
   EXPECT_TRUE(!extension_path.empty());
-  for (extensions::ExtensionSet::const_iterator iter = extensions->begin();
-       iter != extensions->end(); ++iter) {
-    if ((*iter)->path() == extension_path) {
-      return iter->get();
+  for (const scoped_refptr<const Extension>& extension : extensions) {
+    if (extension->path() == extension_path) {
+      return extension.get();
     }
   }
   return NULL;
 }
 
 void ExtensionBrowserTest::SetUp() {
   test_extension_cache_.reset(new extensions::ExtensionCacheFake());
   InProcessBrowserTest::SetUp();
 }
 
@@ skipping 39 matching lines @@
   return LoadExtensionWithInstallParam(path, flags, std::string());
 }
 
 const extensions::Extension*
 ExtensionBrowserTest::LoadExtensionWithInstallParam(
     const base::FilePath& path,
     int flags,
     const std::string& install_param) {
   ExtensionService* service = extensions::ExtensionSystem::Get(
       profile())->extension_service();
+  ExtensionRegistry* registry = ExtensionRegistry::Get(profile());
   {
     observer_->Watch(extensions::NOTIFICATION_EXTENSION_LOADED_DEPRECATED,
                      content::NotificationService::AllSources());
 
     scoped_refptr<extensions::UnpackedInstaller> installer(
         extensions::UnpackedInstaller::Create(service));
     installer->set_prompt_for_plugins(false);
     installer->set_require_modern_manifest_version(
         (flags & kFlagAllowOldManifestVersions) == 0);
     installer->Load(path);
 
     observer_->Wait();
   }
 
   // Find the loaded extension by its path. See crbug.com/59531 for why
   // we cannot just use last_loaded_extension_id().
-  const Extension* extension = GetExtensionByPath(service->extensions(), path);
+  const Extension* extension =
+      GetExtensionByPath(registry->enabled_extensions(), path);
   if (!extension)
     return NULL;
 
   if (!(flags & kFlagIgnoreManifestWarnings)) {
     const std::vector<extensions::InstallWarning>& install_warnings =
         extension->install_warnings();
     if (!install_warnings.empty()) {
       std::string install_warnings_message = base::StringPrintf(
           "Unexpected warnings when loading test extension %s:\n",
           path.AsUTF8Unsafe().c_str());
 
       for (std::vector<extensions::InstallWarning>::const_iterator it =
           install_warnings.begin(); it != install_warnings.end(); ++it) {
         install_warnings_message += "  " + it->message + "\n";
       }
 
       EXPECT_EQ(0u, extension->install_warnings().size())
           << install_warnings_message;
       return NULL;
     }
   }
 
   const std::string extension_id = extension->id();
 
   if (!install_param.empty()) {
     extensions::ExtensionPrefs::Get(profile())
         ->SetInstallParam(extension_id, install_param);
     // Re-enable the extension if needed.
-    if (service->extensions()->Contains(extension_id)) {
+    if (registry->enabled_extensions().Contains(extension_id)) {
       content::WindowedNotificationObserver load_signal(
           extensions::NOTIFICATION_EXTENSION_LOADED_DEPRECATED,
           content::Source<Profile>(profile()));
       // Reload the extension so that the
       // NOTIFICATION_EXTENSION_LOADED_DEPRECATED
       // observers may access |install_param|.
       service->ReloadExtension(extension_id);
       load_signal.Wait();
       extension = service->GetExtensionById(extension_id, false);
       CHECK(extension) << extension_id << " not found after reloading.";
@@ skipping 35 matching lines @@
     return NULL;
 
   return extension;
 }
 
 const Extension* ExtensionBrowserTest::LoadExtensionAsComponentWithManifest(
     const base::FilePath& path,
     const base::FilePath::CharType* manifest_relative_path) {
   ExtensionService* service = extensions::ExtensionSystem::Get(
       profile())->extension_service();
+  ExtensionRegistry* registry = ExtensionRegistry::Get(profile());
 
   std::string manifest;
   if (!base::ReadFileToString(path.Append(manifest_relative_path), &manifest)) {
     return NULL;
   }
 
   std::string extension_id = service->component_loader()->Add(manifest, path);
-  const Extension* extension = service->extensions()->GetByID(extension_id);
+  const Extension* extension =
+      registry->enabled_extensions().GetByID(extension_id);
   if (!extension)
     return NULL;
   observer_->set_last_loaded_extension_id(extension->id());
   return extension;
 }
 
 const Extension* ExtensionBrowserTest::LoadExtensionAsComponent(
     const base::FilePath& path) {
   return LoadExtensionAsComponentWithManifest(path,
                                               extensions::kManifestFilename);
@@ skipping 175 matching lines @@
     const base::FilePath& path,
     InstallUIType ui_type,
     int expected_change,
     Manifest::Location install_source,
     Browser* browser,
     Extension::InitFromValueFlags creation_flags,
     bool install_immediately,
     bool is_ephemeral) {
   ExtensionService* service =
       extensions::ExtensionSystem::Get(profile())->extension_service();
+  ExtensionRegistry* registry = ExtensionRegistry::Get(profile());
   service->set_show_extensions_prompts(false);
-  size_t num_before = service->extensions()->size();
+  size_t num_before = registry->enabled_extensions().size();
 
   {
     scoped_ptr<ExtensionInstallPrompt> install_ui;
     if (ui_type == INSTALL_UI_TYPE_CANCEL) {
       install_ui.reset(new MockAbortExtensionInstallPrompt());
     } else if (ui_type == INSTALL_UI_TYPE_NORMAL) {
       install_ui.reset(new ExtensionInstallPrompt(
           browser->tab_strip_model()->GetActiveWebContents()));
     } else if (ui_type == INSTALL_UI_TYPE_AUTO_CONFIRM) {
       install_ui.reset(new MockAutoConfirmExtensionInstallPrompt(
@@ skipping 23 matching lines @@
 
     observer_->Watch(
         extensions::NOTIFICATION_CRX_INSTALLER_DONE,
         content::Source<extensions::CrxInstaller>(installer.get()));
 
     installer->InstallCrx(crx_path);
 
     observer_->Wait();
   }
 
-  size_t num_after = service->extensions()->size();
+  size_t num_after = registry->enabled_extensions().size();
   EXPECT_EQ(num_before + expected_change, num_after);
   if (num_before + expected_change != num_after) {
     VLOG(1) << "Num extensions before: " << base::IntToString(num_before)
             << " num after: " << base::IntToString(num_after)
             << " Installed extensions follow:";
 
-    for (extensions::ExtensionSet::const_iterator it =
-             service->extensions()->begin();
-         it != service->extensions()->end(); ++it)
-      VLOG(1) << "  " << (*it)->id();
+    for (const scoped_refptr<const Extension>& extension :
+         registry->enabled_extensions())
+      VLOG(1) << "  " << extension->id();
 
     VLOG(1) << "Errors follow:";
     const std::vector<base::string16>* errors =
         ExtensionErrorReporter::GetInstance()->GetErrors();
     for (std::vector<base::string16>::const_iterator iter = errors->begin();
          iter != errors->end(); ++iter)
       VLOG(1) << *iter;
 
     return NULL;
   }
@@ skipping 118 matching lines @@
   return extensions::browsertest_util::ExecuteScriptInBackgroundPage(
       profile(), extension_id, script);
 }
 
 bool ExtensionBrowserTest::ExecuteScriptInBackgroundPageNoWait(
     const std::string& extension_id,
     const std::string& script) {
   return extensions::browsertest_util::ExecuteScriptInBackgroundPageNoWait(
       profile(), extension_id, script);
 }