Move ExtensionService::GetExtensionById() to ExtensionRegistry

chrome/browser/themes/theme_service_unittest.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/themes/theme_service.h"
 
 #include "base/file_util.h"
 #include "base/path_service.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/extensions/extension_service_unittest.h"
 #include "chrome/browser/extensions/unpacked_installer.h"
 #include "chrome/browser/managed_mode/managed_user_service.h"
 #include "chrome/browser/managed_mode/managed_user_service_factory.h"
 #include "chrome/browser/themes/custom_theme_supplier.h"
 #include "chrome/browser/themes/theme_service_factory.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/test/base/testing_browser_process.h"
 #include "chrome/test/base/testing_profile.h"
 #include "chrome/test/base/testing_profile_manager.h"
 #include "content/public/test/test_utils.h"
+#include "extensions/browser/extension_registry.h"
 #include "extensions/common/extension.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
+using extensions::ExtensionRegistry;
+
 namespace theme_service_internal {
 
 class ThemeServiceTest : public ExtensionServiceTestBase {
  public:
   ThemeServiceTest() : is_managed_(false),
+                       registry_(NULL),
                        manager_(TestingBrowserProcess::GetGlobal()) {}
   virtual ~ThemeServiceTest() {}
 
   // Moves a minimal theme to |temp_dir_path| and unpacks it from that
   // directory.
   std::string LoadUnpackedThemeAt(const base::FilePath& temp_dir) {
     base::FilePath dst_manifest_path = temp_dir.AppendASCII("manifest.json");
     base::FilePath test_data_dir;
     EXPECT_TRUE(PathService::Get(chrome::DIR_TEST_DATA, &test_data_dir));
     base::FilePath src_manifest_path =
@@ skipping 38 matching lines @@
   }
 
   virtual void SetUp() {
     ExtensionServiceTestBase::SetUp();
     ExtensionServiceTestBase::ExtensionServiceInitParams params =
         CreateDefaultInitParams();
     params.profile_is_managed = is_managed_;
     InitializeExtensionService(params);
     service_->Init();
     ASSERT_TRUE(manager_.SetUp());
+    registry_ = ExtensionRegistry::Get(profile_.get());
+    ASSERT_TRUE(registry_);
   }
 
   const CustomThemeSupplier* get_theme_supplier(ThemeService* theme_service) {
     return theme_service->get_theme_supplier();
   }
 
   TestingProfileManager* manager() {
     return &manager_;
   }
 
  protected:
   bool is_managed_;
+  ExtensionRegistry* registry_;
 
  private:
   TestingProfileManager manager_;
 };
 
 // Installs then uninstalls a theme and makes sure that the ThemeService
 // reverts to the default theme after the uninstall.
 TEST_F(ThemeServiceTest, ThemeInstallUninstall) {
   ThemeService* theme_service =
       ThemeServiceFactory::GetForProfile(profile_.get());
@@ skipping 32 matching lines @@
   EXPECT_FALSE(theme_service->UsingDefaultTheme());
   EXPECT_EQ(extension1_id, theme_service->GetThemeID());
   EXPECT_TRUE(service_->IsExtensionEnabled(extension1_id));
 
   // Show an infobar to prevent the current theme from being uninstalled.
   theme_service->OnInfobarDisplayed();
 
   const std::string& extension2_id = LoadUnpackedThemeAt(temp_dir2.path());
   EXPECT_EQ(extension2_id, theme_service->GetThemeID());
   EXPECT_TRUE(service_->IsExtensionEnabled(extension2_id));
-  EXPECT_TRUE(service_->GetExtensionById(extension1_id,
-      ExtensionService::INCLUDE_DISABLED));
+  EXPECT_TRUE(registry_->GetExtensionById(extension1_id,
+                                          ExtensionRegistry::DISABLED));
 
   // 2) Enabling a disabled theme extension should swap the current theme.
   service_->EnableExtension(extension1_id);
   base::MessageLoop::current()->RunUntilIdle();
   EXPECT_EQ(extension1_id, theme_service->GetThemeID());
   EXPECT_TRUE(service_->IsExtensionEnabled(extension1_id));
-  EXPECT_TRUE(service_->GetExtensionById(extension2_id,
-      ExtensionService::INCLUDE_DISABLED));
+  EXPECT_TRUE(registry_->GetExtensionById(extension2_id,
+                                          ExtensionRegistry::DISABLED));
 
   // 3) Using SetTheme() with a disabled theme should enable and set the
   // theme. This is the case when the user reverts to the previous theme
   // via an infobar.
   const extensions::Extension* extension2 =
       service_->GetInstalledExtension(extension2_id);
   theme_service->SetTheme(extension2);
   base::MessageLoop::current()->RunUntilIdle();
   EXPECT_EQ(extension2_id, theme_service->GetThemeID());
   EXPECT_TRUE(service_->IsExtensionEnabled(extension2_id));
-  EXPECT_TRUE(service_->GetExtensionById(extension1_id,
-      ExtensionService::INCLUDE_DISABLED));
+  EXPECT_TRUE(registry_->GetExtensionById(extension1_id,
+                                          ExtensionRegistry::DISABLED));
 
   // 4) Disabling the current theme extension should revert to the default theme
   // and uninstall any installed theme extensions.
   theme_service->OnInfobarDestroyed();
   EXPECT_FALSE(theme_service->UsingDefaultTheme());
   service_->DisableExtension(extension2_id,
       extensions::Extension::DISABLE_USER_ACTION);
   base::MessageLoop::current()->RunUntilIdle();
   EXPECT_TRUE(theme_service->UsingDefaultTheme());
   EXPECT_FALSE(service_->GetInstalledExtension(extension1_id));
@@ skipping 13 matching lines @@
 
   base::ScopedTempDir temp_dir1;
   ASSERT_TRUE(temp_dir1.CreateUniqueTempDir());
   base::ScopedTempDir temp_dir2;
   ASSERT_TRUE(temp_dir2.CreateUniqueTempDir());
 
   const std::string& extension1_id = LoadUnpackedThemeAt(temp_dir1.path());
   const std::string& extension2_id = LoadUnpackedThemeAt(temp_dir2.path());
 
   // Test the initial state.
-  EXPECT_TRUE(service_->GetExtensionById(extension1_id,
-      ExtensionService::INCLUDE_DISABLED));
+  EXPECT_TRUE(registry_->GetExtensionById(extension1_id,
+                                          ExtensionRegistry::DISABLED));
   EXPECT_EQ(extension2_id, theme_service->GetThemeID());
 
   // 1) Upgrading the current theme should not revert to the default theme.
   content::WindowedNotificationObserver theme_change_observer(
       chrome::NOTIFICATION_BROWSER_THEME_CHANGED,
       content::Source<ThemeService>(theme_service));
   UpdateUnpackedTheme(extension2_id);
 
   // The ThemeService should have sent an theme change notification even though
   // the id of the current theme did not change.
   theme_change_observer.Wait();
 
   EXPECT_EQ(extension2_id, theme_service->GetThemeID());
-  EXPECT_TRUE(service_->GetExtensionById(extension1_id,
-      ExtensionService::INCLUDE_DISABLED));
+  EXPECT_TRUE(registry_->GetExtensionById(extension1_id,
+                                          ExtensionRegistry::DISABLED));
 
   // 2) Upgrading a disabled theme should not change the current theme.
   UpdateUnpackedTheme(extension1_id);
   EXPECT_EQ(extension2_id, theme_service->GetThemeID());
-  EXPECT_TRUE(service_->GetExtensionById(extension1_id,
-      ExtensionService::INCLUDE_DISABLED));
+  EXPECT_TRUE(registry_->GetExtensionById(extension1_id,
+                                          ExtensionRegistry::DISABLED));
 }
 
 class ThemeServiceManagedUserTest : public ThemeServiceTest {
  public:
   ThemeServiceManagedUserTest() {}
   virtual ~ThemeServiceManagedUserTest() {}
 
   virtual void SetUp() OVERRIDE {
     is_managed_ = true;
     ThemeServiceTest::SetUp();
@@ skipping 20 matching lines @@
       ThemeServiceFactory::GetForProfile(profile_.get());
   theme_service->UseDefaultTheme();
   EXPECT_TRUE(theme_service->UsingDefaultTheme());
   EXPECT_TRUE(get_theme_supplier(theme_service));
   EXPECT_EQ(get_theme_supplier(theme_service)->get_theme_type(),
             CustomThemeSupplier::MANAGED_USER_THEME);
 }
 #endif
 
 }; // namespace theme_service_internal