Unpack theme data from extensions off of UI thread.

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/command_line.h"
 #include "base/files/file_util.h"
 #include "base/macros.h"
 #include "base/path_service.h"
 #include "base/run_loop.h"
 #include "base/strings/stringprintf.h"
+#include "base/test/scoped_task_environment.h"
 #include "build/build_config.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/extension_service_test_base.h"
 #include "chrome/browser/extensions/unpacked_installer.h"
 #include "chrome/browser/themes/custom_theme_supplier.h"
 #include "chrome/browser/themes/theme_properties.h"
 #include "chrome/browser/themes/theme_service_factory.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/features.h"
@@ skipping 47 matching lines @@
         test_data_dir.AppendASCII("extensions/theme_minimal/manifest.json");
     EXPECT_TRUE(base::CopyFile(src_manifest_path, dst_manifest_path));
 
     scoped_refptr<extensions::UnpackedInstaller> installer(
         extensions::UnpackedInstaller::Create(service_));
     extensions::TestExtensionRegistryObserver observer(
         ExtensionRegistry::Get(profile()));
     installer->Load(temp_dir);
     std::string extension_id = observer.WaitForExtensionLoaded()->id();
 
-    // Let the ThemeService finish creating the theme pack.
-    base::RunLoop().RunUntilIdle();
+    WaitForThemeInstall();
 
     return extension_id;
   }
 
   // Update the theme with |extension_id|.
   void UpdateUnpackedTheme(const std::string& extension_id) {
     const base::FilePath& path =
         service_->GetInstalledExtension(extension_id)->path();
 
     scoped_refptr<extensions::UnpackedInstaller> installer(
@@ skipping 12 matching lines @@
     }
 
     // Let the ThemeService finish creating the theme pack.
     base::RunLoop().RunUntilIdle();
   }
 
   const CustomThemeSupplier* get_theme_supplier(ThemeService* theme_service) {
     return theme_service->get_theme_supplier();
   }
 
+  void WaitForThemeInstall() {
+    content::WindowedNotificationObserver theme_change_observer(
+        chrome::NOTIFICATION_BROWSER_THEME_CHANGED,
+        content::Source<ThemeService>(
+            ThemeServiceFactory::GetForProfile(profile())));
+    theme_change_observer.Wait();
+  }
+
   // Alpha blends a non-opaque foreground color against an opaque background.
   // This is not the same as color_utils::AlphaBlend() since it gets the opacity
   // from the foreground color and then does not blend the two colors' alpha
   // values together.
   static SkColor AlphaBlend(SkColor foreground, SkColor background) {
     return color_utils::AlphaBlend(SkColorSetA(foreground, SK_AlphaOPAQUE),
                                    background, SkColorGetA(foreground));
   }
 
   // Returns the separator color as the opaque result of blending it atop the
@@ skipping 32 matching lines @@
   EXPECT_TRUE(theme_service->UsingDefaultTheme());
 }
 
 // Test that a theme extension is disabled when not in use. A theme may be
 // installed but not in use if it there is an infobar to revert to the previous
 // theme.
 TEST_F(ThemeServiceTest, DisableUnusedTheme) {
   ThemeService* theme_service =
       ThemeServiceFactory::GetForProfile(profile_.get());
   theme_service->UseDefaultTheme();
-  // Let the ThemeService uninstall unused themes.
-  base::RunLoop().RunUntilIdle();
 
   base::ScopedTempDir temp_dir1;
   ASSERT_TRUE(temp_dir1.CreateUniqueTempDir());
   base::ScopedTempDir temp_dir2;
   ASSERT_TRUE(temp_dir2.CreateUniqueTempDir());
 
   // 1) Installing a theme should disable the previously active theme.
   const std::string& extension1_id = LoadUnpackedThemeAt(temp_dir1.GetPath());
   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.GetPath());
   EXPECT_EQ(extension2_id, theme_service->GetThemeID());
   EXPECT_TRUE(service_->IsExtensionEnabled(extension2_id));
   EXPECT_TRUE(registry_->GetExtensionById(extension1_id,
                                           ExtensionRegistry::DISABLED));
 
   // 2) Enabling a disabled theme extension should swap the current theme.
   service_->EnableExtension(extension1_id);
-  base::RunLoop().RunUntilIdle();
+  WaitForThemeInstall();
   EXPECT_EQ(extension1_id, theme_service->GetThemeID());
   EXPECT_TRUE(service_->IsExtensionEnabled(extension1_id));
   EXPECT_TRUE(registry_->GetExtensionById(extension2_id,
                                           ExtensionRegistry::DISABLED));
 
-  // 3) Using SetTheme() with a disabled theme should enable and set the
+  // 3) Using RevertToTheme() 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::RunLoop().RunUntilIdle();
+  theme_service->RevertToTheme(extension2);
+  WaitForThemeInstall();
   EXPECT_EQ(extension2_id, theme_service->GetThemeID());
   EXPECT_TRUE(service_->IsExtensionEnabled(extension2_id));
   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,
@@ skipping 119 matching lines @@
   ASSERT_TRUE(temp_dir1.CreateUniqueTempDir());
   base::ScopedTempDir temp_dir2;
   ASSERT_TRUE(temp_dir2.CreateUniqueTempDir());
 
   const std::string& extension1_id = LoadUnpackedThemeAt(temp_dir1.GetPath());
   ASSERT_EQ(extension1_id, theme_service->GetThemeID());
 
   // Show an infobar.
   theme_service->OnInfobarDisplayed();
 
-  // Install another theme. Emulate the infobar destroying itself (and
-  // causing unused themes to be uninstalled) as a result of the
-  // NOTIFICATION_BROWSER_THEME_CHANGED notification.
+  // Install another theme. The first extension shouldn't be uninstalled yet as
+  // it should be possible to revert to it. Emulate the infobar destroying
+  // itself as a result of the NOTIFICATION_BROWSER_THEME_CHANGED notification.
   {
     InfobarDestroyerOnThemeChange destroyer(profile_.get());
     const std::string& extension2_id = LoadUnpackedThemeAt(temp_dir2.GetPath());
-    ASSERT_EQ(extension2_id, theme_service->GetThemeID());
-    ASSERT_FALSE(service_->GetInstalledExtension(extension1_id));
+    EXPECT_EQ(extension2_id, theme_service->GetThemeID());
   }
 
+  auto* extension1 = service_->GetInstalledExtension(extension1_id);
+  ASSERT_TRUE(extension1);
+
   // Check that it is possible to reinstall extension1.
-  ASSERT_EQ(extension1_id, LoadUnpackedThemeAt(temp_dir1.GetPath()));
+  ThemeServiceFactory::GetForProfile(profile_.get())->RevertToTheme(extension1);
+  WaitForThemeInstall();
   EXPECT_EQ(extension1_id, theme_service->GetThemeID());
 }
 
 #if BUILDFLAG(ENABLE_SUPERVISED_USERS)
 class ThemeServiceSupervisedUserTest : public ThemeServiceTest {
  public:
   ThemeServiceSupervisedUserTest() {}
   ~ThemeServiceSupervisedUserTest() override {}
 
   void SetUp() override {
@@ skipping 132 matching lines @@
     // it should still be lighter than the tab color.
     separator_color = GetSeparatorColor(tab_color, SK_ColorWHITE);
     separator_luminance = color_utils::GetRelativeLuminance(separator_color);
     EXPECT_LT(separator_luminance, 1);
     EXPECT_GT(separator_luminance, tab_luminance);
   }
 }
 #endif  // !defined(OS_MACOSX)
 
 }; // namespace theme_service_internal