Revert r123782.

chrome/browser/ui/gtk/gtk_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/ui/gtk/theme_service_gtk.h"
+#include "chrome/browser/ui/gtk/gtk_theme_service.h"
 
 #include <gtk/gtk.h>
 
 #include <set>
 #include <string>
 
 #include "base/debug/trace_event.h"
 #include "base/environment.h"
 #include "base/nix/xdg_util.h"
 #include "base/stl_util.h"
@@ skipping 220 matching lines @@
   SkColor shifted = color_utils::HSLShift(gfx::GdkColorToSkColor(*frame_color),
                                                                  shift);
   frame_color->pixel = 0;
   frame_color->red = SkColorGetR(shifted) * ui::kSkiaToGDKMultiplier;
   frame_color->green = SkColorGetG(shifted) * ui::kSkiaToGDKMultiplier;
   frame_color->blue = SkColorGetB(shifted) * ui::kSkiaToGDKMultiplier;
 }
 
 }  // namespace
 
-GtkWidget* ThemeServiceGtk::icon_widget_ = NULL;
-gfx::Image* ThemeServiceGtk::default_folder_icon_ = NULL;
-gfx::Image* ThemeServiceGtk::default_bookmark_icon_ = NULL;
+GtkWidget* GtkThemeService::icon_widget_ = NULL;
+gfx::Image* GtkThemeService::default_folder_icon_ = NULL;
+gfx::Image* GtkThemeService::default_bookmark_icon_ = NULL;
 
 // static
-ThemeServiceGtk* ThemeServiceGtk::GetFrom(Profile* profile) {
-  return static_cast<ThemeServiceGtk*>(
+GtkThemeService* GtkThemeService::GetFrom(Profile* profile) {
+  return static_cast<GtkThemeService*>(
       ThemeServiceFactory::GetForProfile(profile));
 }
 
-ThemeServiceGtk::ThemeServiceGtk()
+GtkThemeService::GtkThemeService()
     : ThemeService(),
       use_gtk_(false),
       fake_window_(gtk_window_new(GTK_WINDOW_TOPLEVEL)),
       fake_frame_(chrome_gtk_frame_new()),
       signals_(new ui::GtkSignalRegistrar),
       fullscreen_icon_set_(NULL) {
   fake_label_.Own(gtk_label_new(""));
   fake_entry_.Own(gtk_entry_new());
   fake_menu_item_.Own(gtk_menu_item_new());
 
   // Only realized widgets receive style-set notifications, which we need to
   // broadcast new theme images and colors. Only realized widgets have style
   // properties, too, which we query for some colors.
   gtk_widget_realize(fake_frame_);
   gtk_widget_realize(fake_window_);
   signals_->Connect(fake_frame_, "style-set",
                     G_CALLBACK(&OnStyleSetThunk), this);
 }
 
-ThemeServiceGtk::~ThemeServiceGtk() {
+GtkThemeService::~GtkThemeService() {
   gtk_widget_destroy(fake_window_);
   gtk_widget_destroy(fake_frame_);
   fake_label_.Destroy();
   fake_entry_.Destroy();
   fake_menu_item_.Destroy();
 
   FreeIconSets();
 
   // We have to call this because FreePlatformCached() in ~ThemeService
   // doesn't call the right virutal FreePlatformCaches.
   FreePlatformCaches();
 }
 
-void ThemeServiceGtk::Init(Profile* profile) {
+void GtkThemeService::Init(Profile* profile) {
   registrar_.Init(profile->GetPrefs());
   registrar_.Add(prefs::kUsesSystemTheme, this);
   use_gtk_ = profile->GetPrefs()->GetBoolean(prefs::kUsesSystemTheme);
   ThemeService::Init(profile);
 }
 
-SkBitmap* ThemeServiceGtk::GetBitmapNamed(int id) const {
+SkBitmap* GtkThemeService::GetBitmapNamed(int id) const {
   // TODO(erg): Remove this const cast. The gfx::Image interface returns its
   // images const. GetBitmapNamed() also should but doesn't and has a million
   // callsites.
   return const_cast<SkBitmap*>(GetImageNamed(id)->ToSkBitmap());
 }
 
-const gfx::Image* ThemeServiceGtk::GetImageNamed(int id) const {
+const gfx::Image* GtkThemeService::GetImageNamed(int id) const {
   // Try to get our cached version:
   ImageCache::const_iterator it = gtk_images_.find(id);
   if (it != gtk_images_.end())
     return it->second;
 
   if (use_gtk_ && IsOverridableImage(id)) {
     gfx::Image* image = new gfx::Image(GenerateGtkThemeBitmap(id));
     gtk_images_[id] = image;
     return image;
   }
 
   return ThemeService::GetImageNamed(id);
 }
 
-SkColor ThemeServiceGtk::GetColor(int id) const {
+SkColor GtkThemeService::GetColor(int id) const {
   if (use_gtk_) {
     ColorMap::const_iterator it = colors_.find(id);
     if (it != colors_.end())
       return it->second;
   }
 
   return ThemeService::GetColor(id);
 }
 
-bool ThemeServiceGtk::HasCustomImage(int id) const {
+bool GtkThemeService::HasCustomImage(int id) const {
   if (use_gtk_)
     return IsOverridableImage(id);
 
   return ThemeService::HasCustomImage(id);
 }
 
-void ThemeServiceGtk::InitThemesFor(NotificationObserver* observer) {
+void GtkThemeService::InitThemesFor(NotificationObserver* observer) {
   observer->Observe(chrome::NOTIFICATION_BROWSER_THEME_CHANGED,
                     content::Source<ThemeService>(this),
                     content::NotificationService::NoDetails());
 }
 
-void ThemeServiceGtk::SetTheme(const Extension* extension) {
+void GtkThemeService::SetTheme(const Extension* extension) {
   profile()->GetPrefs()->SetBoolean(prefs::kUsesSystemTheme, false);
   LoadDefaultValues();
   ThemeService::SetTheme(extension);
 }
 
-void ThemeServiceGtk::UseDefaultTheme() {
+void GtkThemeService::UseDefaultTheme() {
   profile()->GetPrefs()->SetBoolean(prefs::kUsesSystemTheme, false);
   LoadDefaultValues();
   ThemeService::UseDefaultTheme();
 }
 
-void ThemeServiceGtk::SetNativeTheme() {
+void GtkThemeService::SetNativeTheme() {
   profile()->GetPrefs()->SetBoolean(prefs::kUsesSystemTheme, true);
   ClearAllThemeData();
   LoadGtkValues();
   NotifyThemeChanged();
 }
 
-bool ThemeServiceGtk::UsingDefaultTheme() const {
+bool GtkThemeService::UsingDefaultTheme() const {
   return !use_gtk_ && ThemeService::UsingDefaultTheme();
 }
 
-bool ThemeServiceGtk::UsingNativeTheme() const {
+bool GtkThemeService::UsingNativeTheme() const {
   return use_gtk_;
 }
 
-void ThemeServiceGtk::Observe(int type,
+void GtkThemeService::Observe(int type,
                               const content::NotificationSource& source,
                               const content::NotificationDetails& details) {
   if ((type == chrome::NOTIFICATION_PREF_CHANGED) &&
       (*content::Details<std::string>(details).ptr() ==
           prefs::kUsesSystemTheme)) {
     use_gtk_ = profile()->GetPrefs()->GetBoolean(prefs::kUsesSystemTheme);
   } else {
     ThemeService::Observe(type, source, details);
   }
 }
 
-GtkWidget* ThemeServiceGtk::BuildChromeButton() {
+GtkWidget* GtkThemeService::BuildChromeButton() {
   GtkWidget* button = HoverControllerGtk::CreateChromeButton();
   gtk_chrome_button_set_use_gtk_rendering(GTK_CHROME_BUTTON(button), use_gtk_);
   chrome_buttons_.push_back(button);
 
   signals_->Connect(button, "destroy", G_CALLBACK(OnDestroyChromeButtonThunk),
                     this);
   return button;
 }
 
-GtkWidget* ThemeServiceGtk::BuildChromeLinkButton(const std::string& text) {
+GtkWidget* GtkThemeService::BuildChromeLinkButton(const std::string& text) {
   GtkWidget* link_button = gtk_chrome_link_button_new(text.c_str());
   gtk_chrome_link_button_set_use_gtk_theme(
       GTK_CHROME_LINK_BUTTON(link_button),
       use_gtk_);
   link_buttons_.push_back(link_button);
 
   signals_->Connect(link_button, "destroy",
                     G_CALLBACK(OnDestroyChromeLinkButtonThunk), this);
 
   return link_button;
 }
 
-GtkWidget* ThemeServiceGtk::BuildLabel(const std::string& text,
+GtkWidget* GtkThemeService::BuildLabel(const std::string& text,
                                        GdkColor color) {
   GtkWidget* label = gtk_label_new(text.empty() ? NULL : text.c_str());
   if (!use_gtk_)
     gtk_widget_modify_fg(label, GTK_STATE_NORMAL, &color);
   labels_.insert(std::make_pair(label, color));
 
   signals_->Connect(label, "destroy", G_CALLBACK(OnDestroyLabelThunk), this);
 
   return label;
 }
 
-GtkWidget* ThemeServiceGtk::CreateToolbarSeparator() {
+GtkWidget* GtkThemeService::CreateToolbarSeparator() {
   GtkWidget* separator = gtk_vseparator_new();
   GtkWidget* alignment = gtk_alignment_new(0, 0, 1, 1);
   gtk_alignment_set_padding(GTK_ALIGNMENT(alignment),
       kSeparatorPadding, kSeparatorPadding, kSeparatorPadding, 0);
   gtk_container_add(GTK_CONTAINER(alignment), separator);
 
   signals_->Connect(separator, "expose-event",
                     G_CALLBACK(OnSeparatorExposeThunk), this);
   return alignment;
 }
 
-GdkColor ThemeServiceGtk::GetGdkColor(int id) const {
+GdkColor GtkThemeService::GetGdkColor(int id) const {
   return gfx::SkColorToGdkColor(GetColor(id));
 }
 
-GdkColor ThemeServiceGtk::GetBorderColor() const {
+GdkColor GtkThemeService::GetBorderColor() const {
   GtkStyle* style = gtk_rc_get_style(fake_window_);
 
   GdkColor text;
   GdkColor bg;
   if (use_gtk_) {
     text = style->text[GTK_STATE_NORMAL];
     bg = style->bg[GTK_STATE_NORMAL];
   } else {
     text = GetGdkColor(COLOR_BOOKMARK_TEXT);
     bg = GetGdkColor(COLOR_TOOLBAR);
   }
 
   // Creates a weighted average between the text and base color where
   // the base color counts more than once.
   GdkColor color;
   color.pixel = 0;
   color.red = (text.red + (bg.red * kBgWeight)) / (1 + kBgWeight);
   color.green = (text.green + (bg.green * kBgWeight)) / (1 + kBgWeight);
   color.blue = (text.blue + (bg.blue * kBgWeight)) / (1 + kBgWeight);
 
   return color;
 }
 
-GtkIconSet* ThemeServiceGtk::GetIconSetForId(int id) const {
+GtkIconSet* GtkThemeService::GetIconSetForId(int id) const {
   if (id == IDR_FULLSCREEN_MENU_BUTTON)
     return fullscreen_icon_set_;
 
   return NULL;
 }
 
-void ThemeServiceGtk::GetScrollbarColors(GdkColor* thumb_active_color,
+void GtkThemeService::GetScrollbarColors(GdkColor* thumb_active_color,
                                          GdkColor* thumb_inactive_color,
                                          GdkColor* track_color) {
   const GdkColor* theme_thumb_active = NULL;
   const GdkColor* theme_thumb_inactive = NULL;
   const GdkColor* theme_trough_color = NULL;
   gtk_widget_style_get(GTK_WIDGET(fake_frame_),
                        "scrollbar-slider-prelight-color", &theme_thumb_active,
                        "scrollbar-slider-normal-color", &theme_thumb_inactive,
                        "scrollbar-trough-color", &theme_trough_color,
                        NULL);
@@ skipping 80 matching lines @@
     *thumb_active_color = *theme_thumb_active;
 
   if (theme_thumb_inactive)
     *thumb_inactive_color = *theme_thumb_inactive;
 
   if (theme_trough_color)
     *track_color = *theme_trough_color;
 }
 
 // static
-gfx::Image* ThemeServiceGtk::GetFolderIcon(bool native) {
+gfx::Image* GtkThemeService::GetFolderIcon(bool native) {
   if (native) {
     if (!icon_widget_)
       icon_widget_ = gtk_window_new(GTK_WINDOW_TOPLEVEL);
     // We never release our ref, so we will leak this on program shutdown.
     if (!default_folder_icon_) {
       GdkPixbuf* pixbuf = gtk_widget_render_icon(
           icon_widget_, GTK_STOCK_DIRECTORY, GTK_ICON_SIZE_MENU, NULL);
       if (pixbuf)
         default_folder_icon_ = new gfx::Image(pixbuf);
     }
     if (default_folder_icon_)
       return default_folder_icon_;
   }
 
   return &ui::ResourceBundle::GetSharedInstance().GetNativeImageNamed(
       IDR_BOOKMARK_BAR_FOLDER);
 }
 
 // static
-gfx::Image* ThemeServiceGtk::GetDefaultFavicon(bool native) {
+gfx::Image* GtkThemeService::GetDefaultFavicon(bool native) {
   if (native) {
     if (!icon_widget_)
       icon_widget_ = gtk_window_new(GTK_WINDOW_TOPLEVEL);
     // We never release our ref, so we will leak this on program shutdown.
     if (!default_bookmark_icon_) {
       GdkPixbuf* pixbuf = gtk_widget_render_icon(
           icon_widget_, GTK_STOCK_FILE, GTK_ICON_SIZE_MENU, NULL);
       if (pixbuf)
         default_bookmark_icon_ = new gfx::Image(pixbuf);
     }
     if (default_bookmark_icon_)
       return default_bookmark_icon_;
   }
 
   return &ui::ResourceBundle::GetSharedInstance().GetNativeImageNamed(
       IDR_DEFAULT_FAVICON);
 }
 
 // static
-bool ThemeServiceGtk::DefaultUsesSystemTheme() {
+bool GtkThemeService::DefaultUsesSystemTheme() {
   scoped_ptr<base::Environment> env(base::Environment::Create());
 
   switch (base::nix::GetDesktopEnvironment(env.get())) {
     case base::nix::DESKTOP_ENVIRONMENT_GNOME:
     case base::nix::DESKTOP_ENVIRONMENT_XFCE:
       return true;
     default:
       return false;
   }
 }
 
-void ThemeServiceGtk::ClearAllThemeData() {
+void GtkThemeService::ClearAllThemeData() {
   colors_.clear();
   tints_.clear();
 
   ThemeService::ClearAllThemeData();
 }
 
-void ThemeServiceGtk::LoadThemePrefs() {
+void GtkThemeService::LoadThemePrefs() {
   if (use_gtk_) {
     LoadGtkValues();
   } else {
     LoadDefaultValues();
     ThemeService::LoadThemePrefs();
   }
 
   RebuildMenuIconSets();
 }
 
-void ThemeServiceGtk::NotifyThemeChanged() {
+void GtkThemeService::NotifyThemeChanged() {
   ThemeService::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_);
   }
 
   for (std::vector<GtkWidget*>::iterator it = link_buttons_.begin();
        it != link_buttons_.end(); ++it) {
     gtk_chrome_link_button_set_use_gtk_theme(
         GTK_CHROME_LINK_BUTTON(*it), use_gtk_);
   }
 
   for (std::map<GtkWidget*, GdkColor>::iterator it = labels_.begin();
        it != labels_.end(); ++it) {
     const GdkColor* color = use_gtk_ ? NULL : &it->second;
     gtk_util::SetLabelColor(it->first, color);
   }
 
   Browser* browser = BrowserList::GetLastActive();
   if (browser && browser->window()) {
     GtkWindow* window = browser->window()->GetNativeHandle();
     gtk_util::SetDefaultWindowIcon(window);
     gtk_util::SetWindowIcon(window, browser->profile());
   }
 }
 
-void ThemeServiceGtk::FreePlatformCaches() {
+void GtkThemeService::FreePlatformCaches() {
   ThemeService::FreePlatformCaches();
   STLDeleteValues(&gtk_images_);
 }
 
-void ThemeServiceGtk::OnStyleSet(GtkWidget* widget,
+void GtkThemeService::OnStyleSet(GtkWidget* widget,
                                  GtkStyle* previous_style) {
   gfx::Image* default_folder_icon = default_folder_icon_;
   gfx::Image* default_bookmark_icon = default_bookmark_icon_;
   default_folder_icon_ = NULL;
   default_bookmark_icon_ = NULL;
 
   if (profile()->GetPrefs()->GetBoolean(prefs::kUsesSystemTheme)) {
     ClearAllThemeData();
     LoadGtkValues();
     NotifyThemeChanged();
   }
 
   RebuildMenuIconSets();
 
   // Free the old icons only after the theme change notification has gone
   // through.
   if (default_folder_icon)
     delete default_folder_icon;
   if (default_bookmark_icon)
     delete default_bookmark_icon;
 }
 
-void ThemeServiceGtk::LoadGtkValues() {
+void GtkThemeService::LoadGtkValues() {
   // Before we start setting images and values, we have to clear out old, stale
   // values. (If we don't do this, we'll regress startup time in the case where
   // someone installs a heavyweight theme, then goes back to GTK.)
   profile()->GetPrefs()->ClearPref(prefs::kCurrentThemeImages);
 
   GtkStyle* frame_style = gtk_rc_get_style(fake_frame_);
 
   GtkStyle* window_style = gtk_rc_get_style(fake_window_);
   SetThemeColorFromGtk(ThemeService::COLOR_CONTROL_BACKGROUND,
                        &window_style->bg[GTK_STATE_NORMAL]);
@@ skipping 78 matching lines @@
                        link_color);
   SetThemeColorFromGtk(ThemeService::COLOR_NTP_SECTION_LINK_UNDERLINE,
                        link_color);
 
   if (link_color && !is_default_link_color)
     gdk_color_free(const_cast<GdkColor*>(link_color));
 
   // Generate the colors that we pass to WebKit.
   focus_ring_color_ = gfx::GdkColorToSkColor(frame_color);
   GdkColor thumb_active_color, thumb_inactive_color, track_color;
-  ThemeServiceGtk::GetScrollbarColors(&thumb_active_color,
+  GtkThemeService::GetScrollbarColors(&thumb_active_color,
                                       &thumb_inactive_color,
                                       &track_color);
   thumb_active_color_ = gfx::GdkColorToSkColor(thumb_active_color);
   thumb_inactive_color_ = gfx::GdkColorToSkColor(thumb_inactive_color);
   track_color_ = gfx::GdkColorToSkColor(track_color);
 
   // Some GTK themes only define the text selection colors on the GtkEntry
   // class, so we need to use that for getting selection colors.
   active_selection_bg_color_ =
       gfx::GdkColorToSkColor(entry_style->base[GTK_STATE_SELECTED]);
   active_selection_fg_color_ =
       gfx::GdkColorToSkColor(entry_style->text[GTK_STATE_SELECTED]);
   inactive_selection_bg_color_ =
       gfx::GdkColorToSkColor(entry_style->base[GTK_STATE_ACTIVE]);
   inactive_selection_fg_color_ =
       gfx::GdkColorToSkColor(entry_style->text[GTK_STATE_ACTIVE]);
 }
 
-GdkColor ThemeServiceGtk::BuildFrameColors(GtkStyle* frame_style) {
+GdkColor GtkThemeService::BuildFrameColors(GtkStyle* frame_style) {
   GdkColor* theme_frame = NULL;
   GdkColor* theme_inactive_frame = NULL;
   GdkColor* theme_incognito_frame = NULL;
   GdkColor* theme_incognito_inactive_frame = NULL;
   gtk_widget_style_get(GTK_WIDGET(fake_frame_),
                        "frame-color", &theme_frame,
                        "inactive-frame-color", &theme_inactive_frame,
                        "incognito-frame-color", &theme_incognito_frame,
                        "incognito-inactive-frame-color",
                        &theme_incognito_inactive_frame,
@@ skipping 32 matching lines @@
       theme_incognito_inactive_frame,
       GetDefaultTint(ThemeService::TINT_FRAME_INCOGNITO_INACTIVE),
       ThemeService::COLOR_FRAME_INCOGNITO_INACTIVE,
       ThemeService::TINT_FRAME_INCOGNITO_INACTIVE);
   if (theme_incognito_inactive_frame)
     gdk_color_free(theme_incognito_inactive_frame);
 
   return frame_color;
 }
 
-void ThemeServiceGtk::LoadDefaultValues() {
+void GtkThemeService::LoadDefaultValues() {
   focus_ring_color_ = SkColorSetARGB(255, 229, 151, 0);
   thumb_active_color_ = SkColorSetRGB(244, 244, 244);
   thumb_inactive_color_ = SkColorSetRGB(234, 234, 234);
   track_color_ = SkColorSetRGB(211, 211, 211);
 
   active_selection_bg_color_ = SkColorSetRGB(30, 144, 255);
   active_selection_fg_color_ = SK_ColorWHITE;
   inactive_selection_bg_color_ = SkColorSetRGB(200, 200, 200);
   inactive_selection_fg_color_ = SkColorSetRGB(50, 50, 50);
 }
 
-void ThemeServiceGtk::RebuildMenuIconSets() {
+void GtkThemeService::RebuildMenuIconSets() {
   FreeIconSets();
 
   GtkStyle* style = gtk_rc_get_style(fake_menu_item_.get());
 
   fullscreen_icon_set_ = gtk_icon_set_new();
   BuildIconFromIDRWithColor(IDR_FULLSCREEN_MENU_BUTTON,
                             style,
                             GTK_STATE_PRELIGHT,
                             fullscreen_icon_set_);
   BuildIconFromIDRWithColor(IDR_FULLSCREEN_MENU_BUTTON,
                             style,
                             GTK_STATE_NORMAL,
                             fullscreen_icon_set_);
 }
 
-void ThemeServiceGtk::SetThemeColorFromGtk(int id, const GdkColor* color) {
+void GtkThemeService::SetThemeColorFromGtk(int id, const GdkColor* color) {
   colors_[id] = gfx::GdkColorToSkColor(*color);
 }
 
-void ThemeServiceGtk::SetThemeTintFromGtk(int id, const GdkColor* color) {
+void GtkThemeService::SetThemeTintFromGtk(int id, const GdkColor* color) {
   color_utils::HSL default_tint = GetDefaultTint(id);
   color_utils::HSL hsl;
   color_utils::SkColorToHSL(gfx::GdkColorToSkColor(*color), &hsl);
 
   if (default_tint.s != -1)
     hsl.s = default_tint.s;
 
   if (default_tint.l != -1)
     hsl.l = default_tint.l;
 
   tints_[id] = hsl;
 }
 
-GdkColor ThemeServiceGtk::BuildAndSetFrameColor(const GdkColor* base,
+GdkColor GtkThemeService::BuildAndSetFrameColor(const GdkColor* base,
                                                 const GdkColor* gtk_base,
                                                 const color_utils::HSL& tint,
                                                 int color_id,
                                                 int tint_id) {
   GdkColor out_color = *base;
   if (gtk_base) {
     // The theme author specified a color to use, use it without modification.
     out_color = *gtk_base;
   } else {
     // Tint the basic color since this is a heuristic color instead of one
     // specified by the theme author.
     GdkColorHSLShift(tint, &out_color);
   }
   SetThemeColorFromGtk(color_id, &out_color);
   SetThemeTintFromGtk(tint_id, &out_color);
 
   return out_color;
 }
 
-void ThemeServiceGtk::FreeIconSets() {
+void GtkThemeService::FreeIconSets() {
   if (fullscreen_icon_set_) {
     gtk_icon_set_unref(fullscreen_icon_set_);
     fullscreen_icon_set_ = NULL;
   }
 }
 
-SkBitmap* ThemeServiceGtk::GenerateGtkThemeBitmap(int id) const {
+SkBitmap* GtkThemeService::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;
@@ skipping 41 matching lines @@
     case IDR_OMNIBOX_STAR_DARK:
     case IDR_OMNIBOX_TTS_DARK: {
       return GenerateTintedIcon(id, selected_entry_tint_);
     }
     default: {
       return GenerateTintedIcon(id, button_tint_);
     }
   }
 }
 
-SkBitmap* ThemeServiceGtk::GenerateFrameImage(
+SkBitmap* GtkThemeService::GenerateFrameImage(
     int color_id,
     const char* gradient_name) const {
   // We use two colors: the main color (passed in) and a lightened version of
   // that color (which is supposed to match the light gradient at the top of
   // several GTK+ themes, such as Ambiance, Clearlooks or Bluebird).
   ColorMap::const_iterator it = colors_.find(color_id);
   DCHECK(it != colors_.end());
   SkColor base = it->second;
 
   gfx::Canvas canvas(gfx::Size(kToolbarImageWidth, kToolbarImageHeight), true);
@@ skipping 19 matching lines @@
     shader->unref();
 
     canvas.DrawRect(gfx::Rect(0, 0, kToolbarImageWidth, gradient_size), paint);
   }
 
   canvas.FillRect(gfx::Rect(0, gradient_size, kToolbarImageWidth,
                             kToolbarImageHeight - gradient_size), base);
   return new SkBitmap(canvas.ExtractBitmap());
 }
 
-SkBitmap* ThemeServiceGtk::GenerateTabImage(int base_id) const {
+SkBitmap* GtkThemeService::GenerateTabImage(int base_id) const {
   SkBitmap* base_image = GetBitmapNamed(base_id);
   SkBitmap bg_tint = SkBitmapOperations::CreateHSLShiftedBitmap(
       *base_image, GetTint(ThemeService::TINT_BACKGROUND_TAB));
   return new SkBitmap(SkBitmapOperations::CreateTiledBitmap(
       bg_tint, 0, 0, bg_tint.width(), bg_tint.height()));
 }
 
-SkBitmap* ThemeServiceGtk::GenerateTintedIcon(
+SkBitmap* GtkThemeService::GenerateTintedIcon(
     int base_id,
     const color_utils::HSL& tint) const {
   ui::ResourceBundle& rb = ui::ResourceBundle::GetSharedInstance();
   return new SkBitmap(SkBitmapOperations::CreateHSLShiftedBitmap(
       *rb.GetBitmapNamed(base_id), tint));
 }
 
-void ThemeServiceGtk::GetNormalButtonTintHSL(
+void GtkThemeService::GetNormalButtonTintHSL(
     color_utils::HSL* tint) const {
   GtkStyle* window_style = gtk_rc_get_style(fake_window_);
   const GdkColor accent_gdk_color = window_style->bg[GTK_STATE_SELECTED];
   const GdkColor base_color = window_style->base[GTK_STATE_NORMAL];
 
   GtkStyle* label_style = gtk_rc_get_style(fake_label_.get());
   const GdkColor text_color = label_style->fg[GTK_STATE_NORMAL];
 
   PickButtonTintFromColors(accent_gdk_color, text_color, base_color, tint);
 }
 
-void ThemeServiceGtk::GetNormalEntryForegroundHSL(
+void GtkThemeService::GetNormalEntryForegroundHSL(
     color_utils::HSL* tint) const {
   GtkStyle* window_style = gtk_rc_get_style(fake_window_);
   const GdkColor accent_gdk_color = window_style->bg[GTK_STATE_SELECTED];
 
   GtkStyle* style = gtk_rc_get_style(fake_entry_.get());
   const GdkColor text_color = style->text[GTK_STATE_NORMAL];
   const GdkColor base_color = style->base[GTK_STATE_NORMAL];
 
   PickButtonTintFromColors(accent_gdk_color, text_color, base_color, tint);
 }
 
-void ThemeServiceGtk::GetSelectedEntryForegroundHSL(
+void GtkThemeService::GetSelectedEntryForegroundHSL(
     color_utils::HSL* tint) const {
   // The simplest of all the tints. We just use the selected text in the entry
   // since the icons tinted this way will only be displayed against
   // base[GTK_STATE_SELECTED].
   GtkStyle* style = gtk_rc_get_style(fake_entry_.get());
   const GdkColor color = style->text[GTK_STATE_SELECTED];
   color_utils::SkColorToHSL(gfx::GdkColorToSkColor(color), tint);
 }
 
-void ThemeServiceGtk::OnDestroyChromeButton(GtkWidget* button) {
+void GtkThemeService::OnDestroyChromeButton(GtkWidget* button) {
   std::vector<GtkWidget*>::iterator it =
       find(chrome_buttons_.begin(), chrome_buttons_.end(), button);
   if (it != chrome_buttons_.end())
     chrome_buttons_.erase(it);
 }
 
-void ThemeServiceGtk::OnDestroyChromeLinkButton(GtkWidget* button) {
+void GtkThemeService::OnDestroyChromeLinkButton(GtkWidget* button) {
   std::vector<GtkWidget*>::iterator it =
       find(link_buttons_.begin(), link_buttons_.end(), button);
   if (it != link_buttons_.end())
     link_buttons_.erase(it);
 }
 
-void ThemeServiceGtk::OnDestroyLabel(GtkWidget* button) {
+void GtkThemeService::OnDestroyLabel(GtkWidget* button) {
   std::map<GtkWidget*, GdkColor>::iterator it = labels_.find(button);
   if (it != labels_.end())
     labels_.erase(it);
 }
 
-gboolean ThemeServiceGtk::OnSeparatorExpose(GtkWidget* widget,
+gboolean GtkThemeService::OnSeparatorExpose(GtkWidget* widget,
                                             GdkEventExpose* event) {
-  UNSHIPPED_TRACE_EVENT0("ui::gtk", "ThemeServiceGtk::OnSeparatorExpose");
+  UNSHIPPED_TRACE_EVENT0("ui::gtk", "GtkThemeService::OnSeparatorExpose");
   if (UsingNativeTheme())
     return FALSE;
 
   cairo_t* cr = gdk_cairo_create(gtk_widget_get_window(widget));
   gdk_cairo_rectangle(cr, &event->area);
   cairo_clip(cr);
 
   GdkColor bottom_color = GetGdkColor(ThemeService::COLOR_TOOLBAR);
   double bottom_color_rgb[] = {
       static_cast<double>(bottom_color.red / 257) / 255.0,
@@ skipping 22 matching lines @@
   cairo_new_path(cr);
   cairo_set_line_width(cr, 1.0);
   cairo_move_to(cr, start_x, allocation.y);
   cairo_line_to(cr, start_x, allocation.y + allocation.height);
   cairo_stroke(cr);
   cairo_destroy(cr);
   cairo_pattern_destroy(pattern);
 
   return TRUE;
 }