Revert changes to have ExtensionService notify ThemeService directly

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 "base/bind.h"
 #include "base/memory/ref_counted_memory.h"
 #include "base/sequenced_task_runner.h"
 #include "base/string_split.h"
@@ skipping 206 matching lines @@
 }
 
 ThemeService::~ThemeService() {
   FreePlatformCaches();
 }
 
 void ThemeService::Init(Profile* profile) {
   DCHECK(CalledOnValidThread());
   profile_ = profile;
 
+  // Listen to EXTENSION_LOADED instead of EXTENSION_INSTALLED because
+  // the extension cannot yet be found via GetExtensionById() if it is
+  // installed but not loaded (which may confuse listeners to
+  // BROWSER_THEME_CHANGED).
+  registrar_.Add(this,
+                 chrome::NOTIFICATION_EXTENSION_LOADED,
+                 content::Source<Profile>(profile_));
+
   LoadThemePrefs();
 
   theme_syncable_service_.reset(new ThemeSyncableService(profile_, this));
 }
 
 gfx::Image ThemeService::GetImageNamed(int id) const {
   DCHECK(CalledOnValidThread());
 
   const gfx::Image* image = NULL;
 
@@ skipping 98 matching lines @@
 }
 
 void ThemeService::SetTheme(const Extension* extension) {
   // Clear our image cache.
   FreePlatformCaches();
 
   DCHECK(extension);
   DCHECK(extension->is_theme());
 
   BuildFromExtension(extension);
-  SaveThemeIDForProfile(profile_, extension->id());
+  SaveThemeID(extension->id());
 
   NotifyThemeChanged();
   content::RecordAction(UserMetricsAction("Themes_Installed"));
 }
 
+void ThemeService::RemoveUnusedThemes() {
+  if (!profile_)
+    return;
+  ExtensionService* service = profile_->GetExtensionService();
+  if (!service)
+    return;
+  std::string current_theme = GetThemeID();
+  std::vector<std::string> remove_list;
+  const ExtensionSet* extensions = service->extensions();
+  for (ExtensionSet::const_iterator it = extensions->begin();
+       it != extensions->end(); ++it) {
+    if ((*it)->is_theme() && (*it)->id() != current_theme) {
+      remove_list.push_back((*it)->id());
+    }
+  }
+  for (size_t i = 0; i < remove_list.size(); ++i)
+    service->UninstallExtension(remove_list[i], false, NULL);
+}
+
 void ThemeService::UseDefaultTheme() {
   ClearAllThemeData();
   NotifyThemeChanged();
   content::RecordAction(UserMetricsAction("Themes_Reset"));
 }
 
 void ThemeService::SetNativeTheme() {
   UseDefaultTheme();
 }
 
 bool ThemeService::UsingDefaultTheme() const {
   std::string id = GetThemeID();
   return id == ThemeService::kDefaultThemeID ||
       id == kDefaultThemeGalleryID;
 }
 
 bool ThemeService::UsingNativeTheme() const {
   return UsingDefaultTheme();
 }
 
-void ThemeService::OnInfobarDisplayed() {
-  number_of_infobars_++;
-}
-
-void ThemeService::OnInfobarDestroyed() {
-  number_of_infobars_--;
-
-  if (number_of_infobars_ == 0)
-    RemoveUnusedThemesForProfile(profile_);
+std::string ThemeService::GetThemeID() const {
+  return profile_->GetPrefs()->GetString(prefs::kCurrentThemeID);
 }
 
 // static
-std::string ThemeService::GetThemeIDForProfile(Profile* profile) {
-  return profile->GetPrefs()->GetString(prefs::kCurrentThemeID);
-}
-
-// static
-void ThemeService::SaveThemeIDForProfile(
-    Profile* profile,
-    const std::string& id) {
-  profile->GetPrefs()->SetString(prefs::kCurrentThemeID, id);
-}
-
-// static
-void ThemeService::RemoveUnusedThemesForProfile(Profile* profile) {
-  ExtensionService* extension_service =
-      extensions::ExtensionSystem::Get(profile)->extension_service();
-  if (!extension_service)
-    return;
-  std::string current_theme = GetThemeIDForProfile(profile);
-  std::vector<std::string> remove_list;
-  const ExtensionSet* extensions = extension_service->extensions();
-  for (ExtensionSet::const_iterator it = extensions->begin();
-       it != extensions->end(); ++it) {
-    if ((*it)->is_theme() && (*it)->id() != current_theme) {
-      remove_list.push_back((*it)->id());
-    }
-  }
-  for (size_t i = 0; i < remove_list.size(); ++i)
-    extension_service->UninstallExtension(remove_list[i], false, NULL);
-}
-
-std::string ThemeService::GetThemeID() const {
-  return GetThemeIDForProfile(profile_);
-}
-
-// static
 std::string ThemeService::AlignmentToString(int alignment) {
   // Convert from an AlignmentProperty back into a string.
   std::string vertical_string(kAlignmentCenter);
   std::string horizontal_string(kAlignmentCenter);
 
   if (alignment & ThemeService::ALIGN_TOP)
     vertical_string = kAlignmentTop;
   else if (alignment & ThemeService::ALIGN_BOTTOM)
     vertical_string = kAlignmentBottom;
 
@@ skipping 171 matching lines @@
 
   return GetDefaultTint(id);
 }
 
 void ThemeService::ClearAllThemeData() {
   // Clear our image cache.
   FreePlatformCaches();
   theme_pack_ = NULL;
 
   profile_->GetPrefs()->ClearPref(prefs::kCurrentThemePackFilename);
-  SaveThemeIDForProfile(profile_, kDefaultThemeID);
+  SaveThemeID(kDefaultThemeID);
 }
 
 void ThemeService::LoadThemePrefs() {
   PrefService* prefs = profile_->GetPrefs();
 
   std::string current_id = GetThemeID();
   if (current_id != kDefaultThemeID) {
     bool loaded_pack = false;
 
     // If we don't have a file pack, we're updating from an old version.
@@ skipping 44 matching lines @@
     theme_syncable_service_->OnThemeChange();
   }
 }
 
 #if defined(OS_WIN) || defined(USE_AURA)
 void ThemeService::FreePlatformCaches() {
   // Views (Skia) has no platform image cache to clear.
 }
 #endif
 
+void ThemeService::Observe(int type,
+                           const content::NotificationSource& source,
+                           const content::NotificationDetails& details) {
+  DCHECK(type == chrome::NOTIFICATION_EXTENSION_LOADED);
+  const Extension* extension = content::Details<const Extension>(details).ptr();
+  if (!extension->is_theme()) {
+    return;
+  }
+  SetTheme(extension);
+}
+
 void ThemeService::SavePackName(const 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()) {
     // 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;
 
   // Write the packed file to disk.
   FilePath pack_path = extension->path().Append(chrome::kThemePackFilename);
   service->GetFileTaskRunner()->PostTask(
       FROM_HERE,
       base::Bind(&WritePackToDiskCallback, pack, pack_path));
 
   SavePackName(pack_path);
   theme_pack_ = pack;
 }
 
+void ThemeService::OnInfobarDisplayed() {
+  number_of_infobars_++;
+}
+
+void ThemeService::OnInfobarDestroyed() {
+  number_of_infobars_--;
+
+  if (number_of_infobars_ == 0)
+    RemoveUnusedThemes();
+}
+
 ThemeSyncableService* ThemeService::GetThemeSyncableService() const {
   return theme_syncable_service_.get();
 }