Try 2: Completely redo how themes are stored on disk and processed at install time.

chrome/browser/gtk/gtk_theme_provider.cc

 // Copyright (c) 2009 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/gtk/gtk_theme_provider.h"
 
 #include <gtk/gtk.h>
 
 #include "app/gfx/color_utils.h"
 #include "app/gfx/gtk_util.h"
+#include "app/gfx/skbitmap_operations.h"
+#include "base/stl_util-inl.h"
 #include "chrome/browser/metrics/user_metrics.h"
 #include "chrome/browser/profile.h"
 #include "chrome/browser/gtk/cairo_cached_surface.h"
 #include "chrome/browser/gtk/gtk_chrome_button.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/pref_service.h"
 #include "chrome/common/notification_details.h"
 #include "chrome/common/notification_service.h"
 #include "chrome/common/notification_source.h"
 #include "chrome/common/notification_type.h"
@@ skipping 29 matching lines @@
 // calculate the border color in GTK theme mode.
 const int kBgWeight = 3;
 
 // Converts a GdkColor to a SkColor.
 SkColor GdkToSkColor(GdkColor* color) {
   return SkColorSetRGB(color->red >> 8,
                        color->green >> 8,
                        color->blue >> 8);
 }
 
+// A list of images that we provide while in gtk mode.
+const int kThemeImages[] = {
+  IDR_THEME_TOOLBAR,
+  IDR_THEME_TAB_BACKGROUND,
+  IDR_THEME_TAB_BACKGROUND_INCOGNITO,
+  IDR_THEME_FRAME,
+  IDR_THEME_FRAME_INACTIVE,
+  IDR_THEME_FRAME_INCOGNITO,
+  IDR_THEME_FRAME_INCOGNITO_INACTIVE,
+};
+
+bool IsOverridableImage(int id) {
+  for (size_t i = 0; i < arraysize(kThemeImages); ++i) {
+    if (kThemeImages[i] == id)
+      return true;
+  }
+
+  return false;
+}
+
 }  // namespace
 
 GtkWidget* GtkThemeProvider::icon_widget_ = NULL;
 GdkPixbuf* GtkThemeProvider::default_folder_icon_ = NULL;
 GdkPixbuf* GtkThemeProvider::default_bookmark_icon_ = NULL;
 
 // static
 GtkThemeProvider* GtkThemeProvider::GetFrom(Profile* profile) {
   return static_cast<GtkThemeProvider*>(profile->GetThemeProvider());
 }
 
 GtkThemeProvider::GtkThemeProvider()
     : BrowserThemeProvider(),
       fake_window_(gtk_window_new(GTK_WINDOW_TOPLEVEL)) {
   fake_label_.Own(gtk_label_new(""));
 
   // Only realized widgets receive style-set notifications, which we need to
   // broadcast new theme images and colors.
   gtk_widget_realize(fake_window_);
   g_signal_connect(fake_window_, "style-set", G_CALLBACK(&OnStyleSet), this);
 }
 
 GtkThemeProvider::~GtkThemeProvider() {
   profile()->GetPrefs()->RemovePrefObserver(prefs::kUsesSystemTheme, this);
   gtk_widget_destroy(fake_window_);
   fake_label_.Destroy();
 
-  // We have to call this because ClearCaches in ~BrowserThemeProvider doesn't
-  // call the right virutal FreePlatformCaches.
-  FreePerDisplaySurfaces();
+  // We have to call this because FreePlatformCached() in ~BrowserThemeProvider
+  // doesn't call the right virutal FreePlatformCaches.
+  FreePlatformCaches();
 
   // Disconnect from the destroy signal of any redisual widgets in
   // |chrome_buttons_|.
   for (std::vector<GtkWidget*>::iterator it = chrome_buttons_.begin();
        it != chrome_buttons_.end(); ++it) {
     gtk_signal_disconnect_by_data(GTK_OBJECT(*it), this);
   }
 }
 
 void GtkThemeProvider::Init(Profile* profile) {
   profile->GetPrefs()->AddPrefObserver(prefs::kUsesSystemTheme, this);
   use_gtk_ = profile->GetPrefs()->GetBoolean(prefs::kUsesSystemTheme);
 
   BrowserThemeProvider::Init(profile);
 }
 
+SkBitmap* GtkThemeProvider::GetBitmapNamed(int id) const {
+  if (use_gtk_ && IsOverridableImage(id)) {
+    // Try to get our cached version:
+    ImageCache::const_iterator it = gtk_images_.find(id);
+    if (it != gtk_images_.end())
+      return it->second;
+
+    // We haven't built this image yet:
+    SkBitmap* bitmap = GenerateGtkThemeBitmap(id);
+    gtk_images_[id] = bitmap;
+    return bitmap;
+  }
+
+  return BrowserThemeProvider::GetBitmapNamed(id);
+}
+
+SkColor GtkThemeProvider::GetColor(int id) const {
+  if (use_gtk_) {
+    ColorMap::const_iterator it = colors_.find(id);
+    if (it != colors_.end())
+      return it->second;
+  }
+
+  return BrowserThemeProvider::GetColor(id);
+}
+
+bool GtkThemeProvider::HasCustomImage(int id) const {
+  if (use_gtk_)
+    return IsOverridableImage(id);
+
+  return BrowserThemeProvider::HasCustomImage(id);
+}
+
 void GtkThemeProvider::InitThemesFor(NotificationObserver* observer) {
   observer->Observe(NotificationType::BROWSER_THEME_CHANGED,
                     Source<ThemeProvider>(this),
                     NotificationService::NoDetails());
 }
 
 void GtkThemeProvider::SetTheme(Extension* extension) {
   profile()->GetPrefs()->SetBoolean(prefs::kUsesSystemTheme, false);
   BrowserThemeProvider::SetTheme(extension);
 }
@@ skipping 222 matching lines @@
   BrowserThemeProvider::NotifyThemeChanged();
 
   // Notify all GtkChromeButtons of their new rendering mode:
   for (std::vector<GtkWidget*>::iterator it = chrome_buttons_.begin();
        it != chrome_buttons_.end(); ++it) {
     gtk_chrome_button_set_use_gtk_rendering(
         GTK_CHROME_BUTTON(*it), use_gtk_);
   }
 }
 
-SkBitmap* GtkThemeProvider::LoadThemeBitmap(int id) const {
-  if (use_gtk_) {
-    if (id == IDR_THEME_TOOLBAR) {
-      GtkStyle* style = gtk_rc_get_style(fake_window_);
-      GdkColor* color = &style->bg[GTK_STATE_NORMAL];
-      SkBitmap* bitmap = new SkBitmap;
-      bitmap->setConfig(SkBitmap::kARGB_8888_Config,
-                        kToolbarImageWidth, kToolbarImageHeight);
-      bitmap->allocPixels();
-      bitmap->eraseRGB(color->red >> 8, color->green >> 8, color->blue >> 8);
-      return bitmap;
-    }
-    if ((id == IDR_THEME_TAB_BACKGROUND) ||
-        (id == IDR_THEME_TAB_BACKGROUND_INCOGNITO))
-      return GenerateTabBackgroundBitmapImpl(id);
-  }
-
-  return BrowserThemeProvider::LoadThemeBitmap(id);
-}
-
-void GtkThemeProvider::SaveThemeBitmap(const std::string resource_name,
-                                       int id) const {
-  if (!use_gtk_) {
-    // Prevent us from writing out our mostly unused resources in gtk theme
-    // mode. Simply preventing us from writing this data out in gtk mode isn't
-    // the best design, but this would probably be a very invasive change on
-    // all three platforms otherwise.
-    BrowserThemeProvider::SaveThemeBitmap(resource_name, id);
-  }
-}
-
 void GtkThemeProvider::FreePlatformCaches() {
   BrowserThemeProvider::FreePlatformCaches();
   FreePerDisplaySurfaces();
+  STLDeleteValues(&gtk_images_);
 }
 
 // static
 void GtkThemeProvider::OnStyleSet(GtkWidget* widget,
                                   GtkStyle* previous_style,
                                   GtkThemeProvider* provider) {
   GdkPixbuf* default_folder_icon = default_folder_icon_;
   GdkPixbuf* default_bookmark_icon = default_bookmark_icon_;
   default_folder_icon_ = NULL;
   default_bookmark_icon_ = NULL;
@@ skipping 76 matching lines @@
   if (hsl_difference <= kMinimumLuminanceDifference) {
     // Not enough contrast. Try the text color instead.
     color_utils::HSL label_hsl;
     color_utils::SkColorToHSL(GdkToSkColor(&label_color), &label_hsl);
     double label_difference = fabs(label_hsl.l - toolbar_hsl.l);
     if (label_difference >= kMinimumLuminanceDifference) {
       button_color = label_color;
     }
   }
 
-  SetThemeColorFromGtk(kColorFrame, &frame_color);
+  SetThemeTintFromGtk(BrowserThemeProvider::TINT_BUTTONS, &button_color);
+  SetThemeTintFromGtk(BrowserThemeProvider::TINT_FRAME, &frame_color);
+  SetThemeTintFromGtk(BrowserThemeProvider::TINT_FRAME_INCOGNITO, &frame_color);
+  SetThemeTintFromGtk(BrowserThemeProvider::TINT_BACKGROUND_TAB, &frame_color);
+
+  SetThemeColorFromGtk(BrowserThemeProvider::COLOR_FRAME, &frame_color);
+  BuildTintedFrameColor(BrowserThemeProvider::COLOR_FRAME_INACTIVE,
+                        BrowserThemeProvider::TINT_FRAME_INACTIVE);
+  BuildTintedFrameColor(BrowserThemeProvider::COLOR_FRAME_INCOGNITO,
+                        BrowserThemeProvider::TINT_FRAME_INCOGNITO);
+  BuildTintedFrameColor(BrowserThemeProvider::COLOR_FRAME_INCOGNITO_INACTIVE,
+                        BrowserThemeProvider::TINT_FRAME_INCOGNITO_INACTIVE);
+
   // Skip COLOR_FRAME_INACTIVE and the incognito colors, as they will be
-  // autogenerated from tints.
-  SetThemeColorFromGtk(kColorToolbar, &toolbar_color);
-  SetThemeColorFromGtk(kColorTabText, &label_color);
-  SetThemeColorFromGtk(kColorBookmarkText, &label_color);
-  SetThemeColorFromGtk(kColorControlBackground,
+  // autogenerated from tints. TODO(erg): Still true?
+  SetThemeColorFromGtk(BrowserThemeProvider::COLOR_TOOLBAR, &toolbar_color);
+  SetThemeColorFromGtk(BrowserThemeProvider::COLOR_TAB_TEXT, &label_color);
+  SetThemeColorFromGtk(BrowserThemeProvider::COLOR_BOOKMARK_TEXT, &label_color);
+  SetThemeColorFromGtk(BrowserThemeProvider::COLOR_CONTROL_BACKGROUND,
                        &window_style->bg[GTK_STATE_NORMAL]);
-  SetThemeColorFromGtk(kColorButtonBackground,
+  SetThemeColorFromGtk(BrowserThemeProvider::COLOR_BUTTON_BACKGROUND,
                        &window_style->bg[GTK_STATE_NORMAL]);
 
-  SetThemeTintFromGtk(kTintButtons, &button_color,
-                      kDefaultTintButtons);
-  SetThemeTintFromGtk(kTintFrame, &frame_color,
-                      kDefaultTintFrame);
-  SetThemeTintFromGtk(kTintFrameIncognito,
-                      &frame_color,
-                      kDefaultTintFrameIncognito);
-  SetThemeTintFromGtk(kTintBackgroundTab,
-                      &frame_color,
-                      kDefaultTintBackgroundTab);
-
   // The inactive frame color never occurs naturally in the theme, as it is a
   // tinted version of |frame_color|. We generate another color based on the
   // background tab color, with the lightness and saturation moved in the
   // opposite direction. (We don't touch the hue, since there should be subtle
   // hints of the color in the text.)
-  color_utils::HSL inactive_tab_text_hsl = GetTint(TINT_BACKGROUND_TAB);
+  color_utils::HSL inactive_tab_text_hsl = tints_[TINT_BACKGROUND_TAB];
   if (inactive_tab_text_hsl.l < 0.5)
     inactive_tab_text_hsl.l = kDarkInactiveLuminance;
   else
     inactive_tab_text_hsl.l = kLightInactiveLuminance;
 
   if (inactive_tab_text_hsl.s < 0.5)
     inactive_tab_text_hsl.s = kHeavyInactiveSaturation;
   else
     inactive_tab_text_hsl.s = kLightInactiveSaturation;
 
-  SetColor(kColorBackgroundTabText,
-           color_utils::HSLToSkColor(inactive_tab_text_hsl, 255));
+  colors_[BrowserThemeProvider::COLOR_BACKGROUND_TAB_TEXT] =
+      color_utils::HSLToSkColor(inactive_tab_text_hsl, 255);
 
   // The inactive color/tint is special: We *must* use the exact insensitive
   // color for all inactive windows, otherwise we end up neon pink half the
   // time.
-  SetThemeColorFromGtk(kColorFrameInactive, &inactive_frame_color);
-  SetThemeTintFromGtk(kTintFrameInactive, &inactive_frame_color,
-                      kExactColor);
-  SetThemeTintFromGtk(kTintFrameIncognitoInactive, &inactive_frame_color,
-                      kExactColor);
-
-  force_process_images();
-  GenerateFrameColors();
-  AutoLock lock(themed_image_cache_lock_);
-  GenerateFrameImages();
+  SetThemeColorFromGtk(BrowserThemeProvider::COLOR_FRAME_INACTIVE,
+                       &inactive_frame_color);
+  SetTintToExactColor(BrowserThemeProvider::TINT_FRAME_INACTIVE,
+                      &inactive_frame_color);
+  SetTintToExactColor(BrowserThemeProvider::TINT_FRAME_INCOGNITO_INACTIVE,
+                      &inactive_frame_color);
 }
 
-void GtkThemeProvider::SetThemeColorFromGtk(const char* id, GdkColor* color) {
-  SetColor(id, GdkToSkColor(color));
+void GtkThemeProvider::SetThemeColorFromGtk(int id, GdkColor* color) {
+  colors_[id] = GdkToSkColor(color);
 }
 
-void GtkThemeProvider::SetThemeTintFromGtk(
-    const char* id,
-    GdkColor* color,
-    const color_utils::HSL& default_tint) {
+void GtkThemeProvider::SetThemeTintFromGtk(int id, GdkColor* color) {
+  color_utils::HSL default_tint = GetDefaultTint(id);
   color_utils::HSL hsl;
   color_utils::SkColorToHSL(GdkToSkColor(color), &hsl);
 
   if (default_tint.s != -1)
     hsl.s = default_tint.s;
 
   if (default_tint.l != -1)
     hsl.l = default_tint.l;
-  SetTint(id, hsl);
+
+  tints_[id] = hsl;
+}
+
+void GtkThemeProvider::BuildTintedFrameColor(int color_id, int tint_id) {
+  colors_[color_id] = HSLShift(colors_[BrowserThemeProvider::COLOR_FRAME],
+                               tints_[tint_id]);
+}
+
+void GtkThemeProvider::SetTintToExactColor(int id, GdkColor* color) {
+  color_utils::HSL hsl;
+  color_utils::SkColorToHSL(GdkToSkColor(color), &hsl);
+  tints_[id] = hsl;
 }
 
 void GtkThemeProvider::FreePerDisplaySurfaces() {
   for (PerDisplaySurfaceMap::iterator it = per_display_surfaces_.begin();
        it != per_display_surfaces_.end(); ++it) {
     for (CairoCachedSurfaceMap::iterator jt = it->second.begin();
          jt != it->second.end(); ++jt) {
       delete jt->second;
     }
   }
   per_display_surfaces_.clear();
 }
 
+SkBitmap* GtkThemeProvider::GenerateGtkThemeBitmap(int id) const {
+  switch (id) {
+    case IDR_THEME_TOOLBAR: {
+      GtkStyle* style = gtk_rc_get_style(fake_window_);
+      GdkColor* color = &style->bg[GTK_STATE_NORMAL];
+      SkBitmap* bitmap = new SkBitmap;
+      bitmap->setConfig(SkBitmap::kARGB_8888_Config,
+                        kToolbarImageWidth, kToolbarImageHeight);
+      bitmap->allocPixels();
+      bitmap->eraseRGB(color->red >> 8, color->green >> 8, color->blue >> 8);
+      return bitmap;
+    }
+    case IDR_THEME_TAB_BACKGROUND:
+      return GenerateTabImage(IDR_THEME_FRAME);
+    case IDR_THEME_TAB_BACKGROUND_INCOGNITO:
+      return GenerateTabImage(IDR_THEME_FRAME_INCOGNITO);
+    case IDR_THEME_FRAME:
+      return GenerateFrameImage(BrowserThemeProvider::TINT_FRAME);
+    case IDR_THEME_FRAME_INACTIVE:
+      return GenerateFrameImage(BrowserThemeProvider::TINT_FRAME_INACTIVE);
+    case IDR_THEME_FRAME_INCOGNITO:
+      return GenerateFrameImage(BrowserThemeProvider::TINT_FRAME_INCOGNITO);
+    case IDR_THEME_FRAME_INCOGNITO_INACTIVE: {
+      return GenerateFrameImage(
+          BrowserThemeProvider::TINT_FRAME_INCOGNITO_INACTIVE);
+    }
+  }
+
+  NOTREACHED() << "Invalid bitmap request " << id;
+  return NULL;
+}
+
+SkBitmap* GtkThemeProvider::GenerateFrameImage(int tint_id) const {
+  ResourceBundle& rb = ResourceBundle::GetSharedInstance();
+  scoped_ptr<SkBitmap> frame(new SkBitmap(*rb.GetBitmapNamed(IDR_THEME_FRAME)));
+  TintMap::const_iterator it = tints_.find(tint_id);
+  DCHECK(it != tints_.end());
+  return new SkBitmap(SkBitmapOperations::CreateHSLShiftedBitmap(*frame,
+                                                                 it->second));
+}
+
+SkBitmap* GtkThemeProvider::GenerateTabImage(int base_id) const {
+  SkBitmap* base_image = GetBitmapNamed(base_id);
+  SkBitmap bg_tint = SkBitmapOperations::CreateHSLShiftedBitmap(
+      *base_image, GetTint(BrowserThemeProvider::TINT_BACKGROUND_TAB));
+  return new SkBitmap(SkBitmapOperations::CreateTiledBitmap(
+      bg_tint, 0, 0, bg_tint.width(), bg_tint.height()));
+}
+
 void GtkThemeProvider::OnDestroyChromeButton(GtkWidget* button,
                                              GtkThemeProvider* provider) {
   std::vector<GtkWidget*>::iterator it =
       find(provider->chrome_buttons_.begin(), provider->chrome_buttons_.end(),
            button);
   if (it != provider->chrome_buttons_.end())
     provider->chrome_buttons_.erase(it);
 }