Unpack theme data from extensions off of UI thread.

chrome/browser/themes/theme_service.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 <stddef.h>
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/files/file_util.h"
 #include "base/location.h"
 #include "base/memory/ref_counted_memory.h"
 #include "base/metrics/user_metrics.h"
 #include "base/sequenced_task_runner.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
+#include "base/task_scheduler/post_task.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "build/build_config.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/extensions/extension_service.h"
+#include "chrome/browser/extensions/theme_installed_infobar_delegate.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/themes/browser_theme_pack.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/browser/themes/theme_syncable_service.h"
 #include "chrome/common/chrome_constants.h"
 #include "chrome/common/features.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/grit/theme_resources.h"
@@ skipping 221 matching lines @@
   switch (type) {
     case extensions::NOTIFICATION_EXTENSIONS_READY_DEPRECATED:
       registrar_.Remove(this,
                         extensions::NOTIFICATION_EXTENSIONS_READY_DEPRECATED,
                         content::Source<Profile>(profile_));
       OnExtensionServiceReady();
       break;
     case extensions::NOTIFICATION_EXTENSION_ENABLED: {
       const Extension* extension = Details<const Extension>(details).ptr();
       if (extension->is_theme())
-        SetTheme(extension);
+        DoSetTheme(extension, true);
       break;
     }
     default:
       NOTREACHED();
   }
 }
 
 void ThemeService::SetTheme(const Extension* extension) {
+  DoSetTheme(extension, false);
+}
+
+void ThemeService::RevertToTheme(const Extension* extension) {
   DCHECK(extension->is_theme());
   ExtensionService* service =
       extensions::ExtensionSystem::Get(profile_)->extension_service();
-  if (!service->IsExtensionEnabled(extension->id())) {
-    // |extension| is disabled when reverting to the previous theme via an
-    // infobar.
-    service->EnableExtension(extension->id());
-    // Enabling the extension will call back to SetTheme().
-    return;
-  }
-
-  std::string previous_theme_id = GetThemeID();
-
-  // Clear our image cache.
-  FreePlatformCaches();
-
-  BuildFromExtension(extension);
-  SaveThemeID(extension->id());
-
-  NotifyThemeChanged();
-  base::RecordAction(UserMetricsAction("Themes_Installed"));
-
-  if (previous_theme_id != kDefaultThemeID &&
-      previous_theme_id != extension->id() &&
-      service->GetInstalledExtension(previous_theme_id)) {
-    // Do not disable the previous theme if it is already uninstalled. Sending
-    // NOTIFICATION_BROWSER_THEME_CHANGED causes the previous theme to be
-    // uninstalled when the notification causes the remaining infobar to close
-    // and does not open any new infobars. See crbug.com/468280.
-
-    // Disable the old theme.
-    service->DisableExtension(previous_theme_id,
-                              extensions::Extension::DISABLE_USER_ACTION);
-  }
+  DCHECK(!service->IsExtensionEnabled(extension->id()));
+  // |extension| is disabled when reverting to the previous theme via an
+  // infobar.
+  service->EnableExtension(extension->id());
+  // Enabling the extension will call back to SetTheme().
 }
 
 void ThemeService::UseDefaultTheme() {
   if (ready_)
     base::RecordAction(UserMetricsAction("Themes_Reset"));
 #if BUILDFLAG(ENABLE_SUPERVISED_USERS)
   if (IsSupervisedUser()) {
     SetSupervisedUserTheme();
     return;
   }
@@ skipping 24 matching lines @@
   return profile_->GetPrefs()->GetString(prefs::kCurrentThemeID);
 }
 
 void ThemeService::OnInfobarDisplayed() {
   number_of_infobars_++;
 }
 
 void ThemeService::OnInfobarDestroyed() {
   number_of_infobars_--;
 
-  if (number_of_infobars_ == 0)
+  if (number_of_infobars_ == 0 &&
+      !build_extension_task_tracker_.HasTrackedTasks()) {
     RemoveUnusedThemes(false);
+  }
 }
 
 void ThemeService::RemoveUnusedThemes(bool ignore_infobars) {
   // We do not want to garbage collect themes on startup (|ready_| is false).
   // Themes will get garbage collected after |kRemoveUnusedThemesStartupDelay|.
   if (!profile_ || !ready_)
     return;
   if (!ignore_infobars && number_of_infobars_ != 0)
     return;
 
   ExtensionService* service =
       extensions::ExtensionSystem::Get(profile_)->extension_service();
   if (!service)
     return;
 
   std::string current_theme = GetThemeID();
   std::vector<std::string> remove_list;
   std::unique_ptr<const extensions::ExtensionSet> extensions(
       extensions::ExtensionRegistry::Get(profile_)
           ->GenerateInstalledExtensionsSet());
   extensions::ExtensionPrefs* prefs = extensions::ExtensionPrefs::Get(profile_);
   for (extensions::ExtensionSet::const_iterator it = extensions->begin();
        it != extensions->end(); ++it) {
     const extensions::Extension* extension = it->get();
-    if (extension->is_theme() &&
-        extension->id() != current_theme) {
+    if (extension->is_theme() && extension->id() != current_theme &&
+        extension->id() != building_extension_id_) {
       // Only uninstall themes which are not disabled or are disabled with
       // reason DISABLE_USER_ACTION. We cannot blanket uninstall all disabled
       // themes because externally installed themes are initially disabled.
       int disable_reason = prefs->GetDisableReasons(extension->id());
       if (!prefs->IsExtensionDisabled(extension->id()) ||
           disable_reason == Extension::DISABLE_USER_ACTION) {
         remove_list.push_back((*it)->id());
       }
     }
   }
@@ skipping 181 matching lines @@
     else
       UseDefaultTheme();
     set_ready();
     return;
   }
 
   bool loaded_pack = false;
 
   // If we don't have a file pack, we're updating from an old version.
   base::FilePath path = prefs->GetFilePath(prefs::kCurrentThemePackFilename);
-  if (path != base::FilePath()) {
+  if (!path.empty()) {
     path = path.Append(chrome::kThemePackFilename);
     SwapThemeSupplier(BrowserThemePack::BuildFromDataPack(path, current_id));
     if (theme_supplier_)
       loaded_pack = true;
   }
 
   if (loaded_pack) {
     base::RecordAction(UserMetricsAction("Themes.Loaded"));
     set_ready();
   }
@@ skipping 86 matching lines @@
   for (int delta = lighten ? 64 : -64; delta != 0; delta /= 2) {
     const double luminance = color_utils::GetRelativeLuminance(
         color_utils::AlphaBlend(separator_color, frame_color, alpha));
     if (luminance == target_luminance)
       break;
     alpha += (luminance < target_luminance) ? -delta : delta;
   }
   return SkColorSetA(separator_color, alpha);
 }
 
+void ThemeService::DoSetTheme(const Extension* extension,
+                              bool suppress_infobar) {
+  DCHECK(extension->is_theme());
+  DCHECK(extensions::ExtensionSystem::Get(profile_)
+             ->extension_service()
+             ->IsExtensionEnabled(extension->id()));
+  BuildFromExtension(extension, suppress_infobar);
+}
+
 gfx::ImageSkia* ThemeService::GetImageSkiaNamed(int id, bool incognito) const {
   gfx::Image image = GetImageNamed(id, incognito);
   if (image.IsEmpty())
     return nullptr;
   // TODO(pkotwicz): Remove this const cast.  The gfx::Image interface returns
   // its images const. GetImageSkiaNamed() also should but has many callsites.
   return const_cast<gfx::ImageSkia*>(image.ToImageSkia());
 }
 
 SkColor ThemeService::GetColor(int id, bool incognito) const {
@@ skipping 80 matching lines @@
 
   return image;
 }
 
 void ThemeService::OnExtensionServiceReady() {
   if (!ready_) {
     // If the ThemeService is not ready yet, the custom theme data pack needs to
     // be recreated from the extension.
     MigrateTheme();
     set_ready();
-
-    // Send notification in case anyone requested data and cached it when the
-    // theme service was not ready yet.
-    NotifyThemeChanged();
   }
 
 #if BUILDFLAG(ENABLE_EXTENSIONS)
   theme_observer_.reset(new ThemeObserver(this));
 #endif
 
   registrar_.Add(this,
                  extensions::NOTIFICATION_EXTENSION_ENABLED,
                  content::Source<Profile>(profile_));
 
   base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
       FROM_HERE, base::Bind(&ThemeService::RemoveUnusedThemes,
                             weak_ptr_factory_.GetWeakPtr(), false),
       base::TimeDelta::FromSeconds(kRemoveUnusedThemesStartupDelay));
 }
 
 void ThemeService::MigrateTheme() {
-  // TODO(erg): We need to pop up a dialog informing the user that their
-  // theme is being migrated.
   ExtensionService* service =
       extensions::ExtensionSystem::Get(profile_)->extension_service();
   const Extension* extension =
       service ? service->GetExtensionById(GetThemeID(), false) : nullptr;
   if (extension) {
     DLOG(ERROR) << "Migrating theme";
-    BuildFromExtension(extension);
+    // Theme migration is done on the UI thread. Blocking the UI from appearing
+    // until it's ready is deemed better than showing a blip of the default
+    // theme.
+    scoped_refptr<BrowserThemePack> pack(new BrowserThemePack);
+    BrowserThemePack::BuildFromExtension(extension, pack);
+    OnThemeBuiltFromExtension(extension->id(), pack, true);
     base::RecordAction(UserMetricsAction("Themes.Migrated"));
   } else {
     DLOG(ERROR) << "Theme is mysteriously gone.";
     ClearAllThemeData();
     base::RecordAction(UserMetricsAction("Themes.Gone"));
   }
 }
 
 void ThemeService::SwapThemeSupplier(
     scoped_refptr<CustomThemeSupplier> theme_supplier) {
   if (theme_supplier_)
     theme_supplier_->StopUsingTheme();
   theme_supplier_ = theme_supplier;
   if (theme_supplier_)
     theme_supplier_->StartUsingTheme();
 }
 
 void ThemeService::SavePackName(const base::FilePath& pack_path) {
   profile_->GetPrefs()->SetFilePath(
       prefs::kCurrentThemePackFilename, pack_path);
 }
 
 void ThemeService::SaveThemeID(const std::string& id) {
   profile_->GetPrefs()->SetString(prefs::kCurrentThemeID, id);
 }
 
-void ThemeService::BuildFromExtension(const Extension* extension) {
-  scoped_refptr<BrowserThemePack> pack(
-      BrowserThemePack::BuildFromExtension(extension));
-  if (!pack.get()) {
+void ThemeService::BuildFromExtension(const Extension* extension,
+                                      bool suppress_infobar) {
+  build_extension_task_tracker_.TryCancelAll();
+  building_extension_id_ = extension->id();
+  scoped_refptr<BrowserThemePack> pack(new BrowserThemePack);
+  auto task_runner = base::CreateTaskRunnerWithTraits(
+      {base::MayBlock(), base::TaskPriority::USER_BLOCKING});
+  build_extension_task_tracker_.PostTaskAndReply(
+      task_runner.get(), FROM_HERE,
+      base::Bind(&BrowserThemePack::BuildFromExtension, extension, pack),
+      base::Bind(&ThemeService::OnThemeBuiltFromExtension,
+                 weak_ptr_factory_.GetWeakPtr(), extension->id(), pack,
+                 suppress_infobar));
+}
+
+void ThemeService::OnThemeBuiltFromExtension(
+    const extensions::ExtensionId& extension_id,
+    scoped_refptr<BrowserThemePack> pack,
+    bool suppress_infobar) {
+  if (!pack->is_valid()) {
     // TODO(erg): We've failed to install the theme; perhaps we should tell the
     // user? http://crbug.com/34780
     LOG(ERROR) << "Could not load theme.";
     return;
   }
 
   ExtensionService* service =
       extensions::ExtensionSystem::Get(profile_)->extension_service();
   if (!service)
     return;
+  const Extension* extension = extensions::ExtensionRegistry::Get(profile_)
+                                   ->enabled_extensions()
+                                   .GetByID(extension_id);
+  if (!extension)
+    return;
 
   // Write the packed file to disk.
   service->GetFileTaskRunner()->PostTask(
       FROM_HERE, base::Bind(&WritePackToDiskCallback, base::RetainedRef(pack),
                             extension->path()));
 
   // Save only the extension path. The packed file will be loaded via
   // LoadThemePrefs().
   SavePackName(extension->path());
   SwapThemeSupplier(pack);
+
+  const std::string previous_theme_id = GetThemeID();
+  const bool previous_using_system_theme = UsingSystemTheme();
+
+  // Clear our image cache.
+  FreePlatformCaches();
+  SaveThemeID(extension->id());
+  NotifyThemeChanged();
+
+  // Same old theme, but the theme has changed (migrated) or auto-updated.
+  if (previous_theme_id == extension->id())
+    return;
+
+  base::RecordAction(UserMetricsAction("Themes_Installed"));
+
+  bool can_revert_theme =
+      previous_theme_id == kDefaultThemeID || previous_using_system_theme;
+  if (previous_theme_id != kDefaultThemeID &&
+      service->GetInstalledExtension(previous_theme_id)) {
+    // Do not disable the previous theme if it is already uninstalled. Sending
+    // NOTIFICATION_BROWSER_THEME_CHANGED causes the previous theme to be
+    // uninstalled when the notification causes the remaining infobar to close
+    // and does not open any new infobars. See crbug.com/468280.
+
+    // Disable the old theme.
+    service->DisableExtension(previous_theme_id,
+                              extensions::Extension::DISABLE_USER_ACTION);
+
+    can_revert_theme = true;
+  }
+
+  // Offer to revert to the old theme.
+  if (can_revert_theme && !suppress_infobar) {
+    ThemeInstalledInfoBarDelegate::Create(
+        extension, profile_, previous_theme_id, previous_using_system_theme);
+  }
+  building_extension_id_.clear();
 }
 
 #if BUILDFLAG(ENABLE_SUPERVISED_USERS)
 bool ThemeService::IsSupervisedUser() const {
   return profile_->IsSupervised();
 }
 
 void ThemeService::SetSupervisedUserTheme() {
   SetCustomDefaultTheme(new SupervisedUserTheme);
 }
 #endif