4 files changed, 190 insertions, 157 deletions

diff --git a/chrome/browser/gtk/download_shelf_gtk.cc b/chrome/browser/gtk/download_shelf_gtk.cc
index 8601855..6d94b9f 100644
--- a/chrome/browser/gtk/download_shelf_gtk.cc
+++ b/chrome/browser/gtk/download_shelf_gtk.cc
@@ -201,7 +201,8 @@ void DownloadShelfGtk::Observe(NotificationType type,
     // bad for some dark themes.
     bool use_default_color = theme_provider_->GetColor(
         BrowserThemeProvider::COLOR_BOOKMARK_TEXT) ==
-        BrowserThemeProvider::kDefaultColorBookmarkText;
+        BrowserThemeProvider::GetDefaultColor(
+            BrowserThemeProvider::COLOR_BOOKMARK_TEXT);
     GdkColor bookmark_color = theme_provider_->GetGdkColor(
         BrowserThemeProvider::COLOR_BOOKMARK_TEXT);
     gtk_chrome_link_button_set_normal_color(
diff --git a/chrome/browser/gtk/gtk_theme_provider.cc b/chrome/browser/gtk/gtk_theme_provider.cc
index 4f35110..9330f30 100644
--- a/chrome/browser/gtk/gtk_theme_provider.cc
+++ b/chrome/browser/gtk/gtk_theme_provider.cc
@@ -8,6 +8,8 @@
 
 #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"
@@ -57,6 +59,26 @@ SkColor GdkToSkColor(GdkColor* color) {
                        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;
@@ -84,9 +106,9 @@ GtkThemeProvider::~GtkThemeProvider() {
   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_|.
@@ -103,6 +125,39 @@ void GtkThemeProvider::Init(Profile* profile) {
   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),
@@ -345,40 +400,10 @@ void GtkThemeProvider::NotifyThemeChanged() {
   }
 }
 
-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
@@ -475,34 +500,35 @@ void GtkThemeProvider::LoadGtkValues() {
     }
   }
 
-  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
@@ -513,32 +539,26 @@ void GtkThemeProvider::LoadGtkValues() {
   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);
 
@@ -547,7 +567,19 @@ void GtkThemeProvider::SetThemeTintFromGtk(
 
   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() {
@@ -561,6 +593,55 @@ void GtkThemeProvider::FreePerDisplaySurfaces() {
   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 =
diff --git a/chrome/browser/gtk/gtk_theme_provider.h b/chrome/browser/gtk/gtk_theme_provider.h
index 60d72e7..44fed99 100644
--- a/chrome/browser/gtk/gtk_theme_provider.h
+++ b/chrome/browser/gtk/gtk_theme_provider.h
@@ -40,6 +40,9 @@ class GtkThemeProvider : public BrowserThemeProvider,
   // Sets that we aren't using the system theme, then calls
   // BrowserThemeProvider's implementation.
   virtual void Init(Profile* profile);
+  virtual SkBitmap* GetBitmapNamed(int id) const;
+  virtual SkColor GetColor(int id) const;
+  virtual bool HasCustomImage(int id) const;
   virtual void SetTheme(Extension* extension);
   virtual void UseDefaultTheme();
   virtual void SetNativeTheme();
@@ -86,24 +89,17 @@ class GtkThemeProvider : public BrowserThemeProvider,
   static GdkPixbuf* GetFolderIcon(bool native);
   static GdkPixbuf* GetDefaultFavicon(bool native);
 
- protected:
-  // Possibly creates a theme specific version of theme_toolbar_default.
-  // (minimally acceptable version right now, which is just a fill of the bg
-  // color; this should instead invoke gtk_draw_box(...) for complex theme
-  // engines.)
-  virtual SkBitmap* LoadThemeBitmap(int id) const;
-
  private:
+  typedef std::map<int, SkColor> ColorMap;
+  typedef std::map<int, color_utils::HSL> TintMap;
+  typedef std::map<int, SkBitmap*> ImageCache;
+
   // Load theme data from preferences, possibly picking colors from GTK.
   virtual void LoadThemePrefs();
 
   // Let all the browser views know that themes have changed.
   virtual void NotifyThemeChanged();
 
-  // If use_gtk_ is true, completely ignores this call. Otherwise passes it to
-  // the superclass.
-  virtual void SaveThemeBitmap(const std::string resource_name, int id) const;
-
   // Additionally frees the CairoCachedSurfaces.
   virtual void FreePlatformCaches();
 
@@ -115,9 +111,10 @@ class GtkThemeProvider : public BrowserThemeProvider,
   void LoadGtkValues();
 
   // Sets the underlying theme colors/tints from a GTK color.
-  void SetThemeColorFromGtk(const char* id, GdkColor* color);
-  void SetThemeTintFromGtk(const char* id, GdkColor* color,
-                           const color_utils::HSL& default_tint);
+  void SetThemeColorFromGtk(int id, GdkColor* color);
+  void SetThemeTintFromGtk(int id, GdkColor* color);
+  void BuildTintedFrameColor(int color_id, int tint_id);
+  void SetTintToExactColor(int id, GdkColor* color);
 
   // Split out from FreePlatformCaches so it can be called in our destructor;
   // FreePlatformCaches() is called from the BrowserThemeProvider's destructor,
@@ -125,6 +122,16 @@ class GtkThemeProvider : public BrowserThemeProvider,
   // points to GtkThemeProvider's version.
   void FreePerDisplaySurfaces();
 
+  // Lazily generates each bitmap used in the gtk theme.
+  SkBitmap* GenerateGtkThemeBitmap(int id) const;
+
+  // Tints IDR_THEME_FRAME based based on |tint_id|. Used during lazy
+  // generation of the gtk theme bitmaps.
+  SkBitmap* GenerateFrameImage(int tint_id) const;
+
+  // Takes the base frame image |base_id| and tints it with |tint_id|.
+  SkBitmap* GenerateTabImage(int base_id) const;
+
   // A notification from the GtkChromeButton GObject destructor that we should
   // remove it from our internal list.
   static void OnDestroyChromeButton(GtkWidget* button,
@@ -142,6 +149,15 @@ class GtkThemeProvider : public BrowserThemeProvider,
   // them of theme changes.
   std::vector<GtkWidget*> chrome_buttons_;
 
+  // Tints and colors calculated by LoadGtkValues() that are given to the
+  // caller while |use_gtk_| is true.
+  ColorMap colors_;
+  TintMap tints_;
+
+  // Image cache of lazily created images, created when requested by
+  // GetBitmapNamed().
+  mutable ImageCache gtk_images_;
+
   // Cairo surfaces for each GdkDisplay.
   typedef std::map<int, CairoCachedSurface*> CairoCachedSurfaceMap;
   typedef std::map<GdkDisplay*, CairoCachedSurfaceMap> PerDisplaySurfaceMap;
diff --git a/chrome/browser/gtk/gtk_theme_provider_unittest.cc b/chrome/browser/gtk/gtk_theme_provider_unittest.cc
index c3b85cb..93012ba 100644
--- a/chrome/browser/gtk/gtk_theme_provider_unittest.cc
+++ b/chrome/browser/gtk/gtk_theme_provider_unittest.cc
@@ -35,11 +35,6 @@ class GtkThemeProviderTest : public testing::Test {
     provider_ = GtkThemeProvider::GetFrom(&profile_);
   }
 
-  void UseThemeProvider(GtkThemeProvider* provider) {
-    profile_.UseThemeProvider(provider);
-    provider_ = GtkThemeProvider::GetFrom(&profile_);
-  }
-
  protected:
   TestingProfile profile_;
 
@@ -51,42 +46,11 @@ TEST_F(GtkThemeProviderTest, DefaultValues) {
   BuildProvider();
 
   // Test that we get the default theme colors back when in normal mode.
-  EXPECT_EQ(provider_->GetColor(BrowserThemeProvider::COLOR_FRAME),
-            BrowserThemeProvider::kDefaultColorFrame);
-  EXPECT_EQ(provider_->GetColor(BrowserThemeProvider::COLOR_FRAME_INACTIVE),
-            BrowserThemeProvider::kDefaultColorFrameInactive);
-  EXPECT_EQ(provider_->GetColor(BrowserThemeProvider::COLOR_FRAME_INCOGNITO),
-            BrowserThemeProvider::kDefaultColorFrameIncognito);
-  EXPECT_EQ(provider_->GetColor(
-      BrowserThemeProvider::COLOR_FRAME_INCOGNITO_INACTIVE),
-      BrowserThemeProvider::kDefaultColorFrameIncognitoInactive);
-  EXPECT_EQ(provider_->GetColor(BrowserThemeProvider::COLOR_TOOLBAR),
-            BrowserThemeProvider::kDefaultColorToolbar);
-  EXPECT_EQ(provider_->GetColor(BrowserThemeProvider::COLOR_TAB_TEXT),
-            BrowserThemeProvider::kDefaultColorTabText);
-  EXPECT_EQ(provider_->GetColor(
-      BrowserThemeProvider::COLOR_BACKGROUND_TAB_TEXT),
-      BrowserThemeProvider::kDefaultColorBackgroundTabText);
-  EXPECT_EQ(provider_->GetColor(BrowserThemeProvider::COLOR_BOOKMARK_TEXT),
-            BrowserThemeProvider::kDefaultColorBookmarkText);
-  EXPECT_EQ(provider_->GetColor(BrowserThemeProvider::COLOR_NTP_BACKGROUND),
-            BrowserThemeProvider::kDefaultColorNTPBackground);
-  EXPECT_EQ(provider_->GetColor(BrowserThemeProvider::COLOR_NTP_TEXT),
-            BrowserThemeProvider::kDefaultColorNTPText);
-  EXPECT_EQ(provider_->GetColor(BrowserThemeProvider::COLOR_NTP_LINK),
-            BrowserThemeProvider::kDefaultColorNTPLink);
-  EXPECT_EQ(provider_->GetColor(BrowserThemeProvider::COLOR_NTP_HEADER),
-            BrowserThemeProvider::kDefaultColorNTPHeader);
-  EXPECT_EQ(provider_->GetColor(BrowserThemeProvider::COLOR_NTP_SECTION),
-            BrowserThemeProvider::kDefaultColorNTPSection);
-  EXPECT_EQ(provider_->GetColor(BrowserThemeProvider::COLOR_NTP_SECTION_TEXT),
-            BrowserThemeProvider::kDefaultColorNTPSectionText);
-  EXPECT_EQ(provider_->GetColor(BrowserThemeProvider::COLOR_NTP_SECTION_LINK),
-            BrowserThemeProvider::kDefaultColorNTPSectionLink);
-  EXPECT_EQ(provider_->GetColor(BrowserThemeProvider::COLOR_CONTROL_BACKGROUND),
-            BrowserThemeProvider::kDefaultColorControlBackground);
-  EXPECT_EQ(provider_->GetColor(BrowserThemeProvider::COLOR_BUTTON_BACKGROUND),
-            BrowserThemeProvider::kDefaultColorButtonBackground);
+  for (int i = BrowserThemeProvider::COLOR_FRAME;
+       i <= BrowserThemeProvider::COLOR_BUTTON_BACKGROUND; ++i) {
+    EXPECT_EQ(provider_->GetColor(i), BrowserThemeProvider::GetDefaultColor(i))
+        << "Wrong default color for " << i;
+  }
 }
 
 TEST_F(GtkThemeProviderTest, UsingGtkValues) {
@@ -104,32 +68,3 @@ TEST_F(GtkThemeProviderTest, UsingGtkValues) {
   EXPECT_EQ(provider_->GetColor(BrowserThemeProvider::COLOR_TAB_TEXT),
             GdkToSkColor(&label_color));
 }
-
-// Helper class to GtkThemeProviderTest.UsingGtkFrame.
-class ImageVerifierGtkThemeProvider : public GtkThemeProvider {
- public:
-  ImageVerifierGtkThemeProvider() : theme_toolbar_(NULL) { }
-
-  virtual SkBitmap* LoadThemeBitmap(int id) const {
-    if (id != IDR_THEME_TOOLBAR)
-      return GtkThemeProvider::LoadThemeBitmap(id);
-    theme_toolbar_ = GtkThemeProvider::LoadThemeBitmap(id);
-    return theme_toolbar_;
-  }
-
-  mutable SkBitmap* theme_toolbar_;
-};
-
-TEST_F(GtkThemeProviderTest, InjectsToolbar) {
-  SetUseGtkTheme(true);
-  ImageVerifierGtkThemeProvider* verifier_provider =
-      new ImageVerifierGtkThemeProvider;
-  UseThemeProvider(verifier_provider);
-
-  // Make sure the image we get from the public BrowserThemeProvider interface
-  // is the one we injected through GtkThemeProvider.
-  SkBitmap* image = provider_->GetBitmapNamed(IDR_THEME_TOOLBAR);
-  EXPECT_TRUE(verifier_provider->theme_toolbar_);
-  EXPECT_TRUE(image);
-  EXPECT_EQ(verifier_provider->theme_toolbar_, image);
-}