chrome/browser/ui/gtk/gtk_theme_service.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "chrome/browser/ui/gtk/gtk_theme_service.h"
   6
   7 #include <gtk/gtk.h>
   8
   9 #include <set>
  10 #include <string>
  11
  12 #include "base/debug/trace_event.h"
  13 #include "base/environment.h"
  14 #include "base/nix/mime_util_xdg.h"
  15 #include "base/nix/xdg_util.h"
  16 #include "base/prefs/pref_service.h"
  17 #include "base/stl_util.h"
  18 #include "chrome/browser/chrome_notification_types.h"
  19 #include "chrome/browser/profiles/profile.h"
  20 #include "chrome/browser/themes/custom_theme_supplier.h"
  21 #include "chrome/browser/themes/theme_properties.h"
  22 #include "chrome/browser/themes/theme_service_factory.h"
  23 #include "chrome/browser/ui/browser.h"
  24 #include "chrome/browser/ui/browser_iterator.h"
  25 #include "chrome/browser/ui/browser_window.h"
  26 #include "chrome/browser/ui/gtk/chrome_gtk_frame.h"
  27 #include "chrome/browser/ui/gtk/gtk_chrome_button.h"
  28 #include "chrome/browser/ui/gtk/gtk_chrome_link_button.h"
  29 #include "chrome/browser/ui/gtk/gtk_util.h"
  30 #include "chrome/browser/ui/gtk/hover_controller_gtk.h"
  31 #include "chrome/common/pref_names.h"
  32 #include "content/public/browser/notification_details.h"
  33 #include "content/public/browser/notification_service.h"
  34 #include "content/public/browser/notification_source.h"
  35 #include "extensions/common/extension.h"
  36 #include "grit/theme_resources.h"
  37 #include "grit/ui_resources.h"
  38 #include "third_party/skia/include/core/SkBitmap.h"
  39 #include "third_party/skia/include/core/SkCanvas.h"
  40 #include "third_party/skia/include/core/SkColor.h"
  41 #include "third_party/skia/include/core/SkShader.h"
  42 #include "ui/base/gtk/gtk_hig_constants.h"
  43 #include "ui/base/gtk/gtk_signal_registrar.h"
  44 #include "ui/base/resource/resource_bundle.h"
  45 #include "ui/base/theme_provider.h"
  46 #include "ui/gfx/canvas.h"
  47 #include "ui/gfx/color_utils.h"
  48 #include "ui/gfx/gtk_util.h"
  49 #include "ui/gfx/image/cairo_cached_surface.h"
  50 #include "ui/gfx/image/image.h"
  51 #include "ui/gfx/skbitmap_operations.h"
  52 #include "ui/gfx/skia_util.h"
  53 #include "ui/gfx/skia_utils_gtk.h"
  54
  55 namespace {
  56
  57 // The size of the rendered toolbar image.
  58 const int kToolbarImageWidth = 64;
  59 const int kToolbarImageHeight = 128;
  60
  61 // How much to tint the GTK+ color lighter at the top of the window.
  62 const color_utils::HSL kGtkFrameShift = { -1, -1, 0.58 };
  63
  64 // How much to tint the GTK+ color when an explicit frame color hasn't been
  65 // specified.
  66 const color_utils::HSL kDefaultFrameShift = { -1, -1, 0.4 };
  67
  68 // Values used as the new luminance and saturation values in the inactive tab
  69 // text color.
  70 const double kDarkInactiveLuminance = 0.85;
  71 const double kLightInactiveLuminance = 0.15;
  72 const double kHeavyInactiveSaturation = 0.7;
  73 const double kLightInactiveSaturation = 0.3;
  74
  75 // Number of times that the background color should be counted when trying to
  76 // calculate the border color in GTK theme mode.
  77 const int kBgWeight = 3;
  78
  79 // Padding to left, top and bottom of vertical separators.
  80 const int kSeparatorPadding = 2;
  81
  82 // Default color for links on the NTP when the GTK+ theme doesn't define a
  83 // link color. Constant taken from gtklinkbutton.c.
  84 const GdkColor kDefaultLinkColor = { 0, 0, 0, 0xeeee };
  85
  86 // Middle color of the separator gradient.
  87 const double kMidSeparatorColor[] =
  88     { 194.0 / 255.0, 205.0 / 255.0, 212.0 / 212.0 };
  89 // Top color of the separator gradient.
  90 const double kTopSeparatorColor[] =
  91     { 222.0 / 255.0, 234.0 / 255.0, 248.0 / 255.0 };
  92
  93 // A list of images that we provide while in gtk mode.
  94 const int kThemeImages[] = {
  95   IDR_THEME_TOOLBAR,
  96   IDR_THEME_TAB_BACKGROUND,
  97   IDR_THEME_TAB_BACKGROUND_INCOGNITO,
  98   IDR_THEME_FRAME,
  99   IDR_THEME_FRAME_INACTIVE,
 100   IDR_THEME_FRAME_INCOGNITO,
 101   IDR_THEME_FRAME_INCOGNITO_INACTIVE,
 102 };
 103
 104 // A list of icons used in the autocomplete view that should be tinted to the
 105 // current gtk theme selection color so they stand out against the GtkEntry's
 106 // base color.
 107 // TODO(erg): Decide what to do about other icons that appear in the omnibox,
 108 // e.g. content settings icons.
 109 const int kAutocompleteImages[] = {
 110   IDR_OMNIBOX_EXTENSION_APP,
 111   IDR_OMNIBOX_HTTP,
 112   IDR_OMNIBOX_HTTP_DARK,
 113   IDR_OMNIBOX_SEARCH,
 114   IDR_OMNIBOX_SEARCH_DARK,
 115   IDR_OMNIBOX_STAR,
 116   IDR_OMNIBOX_STAR_DARK,
 117   IDR_OMNIBOX_TTS,
 118   IDR_OMNIBOX_TTS_DARK,
 119 };
 120
 121 bool IsOverridableImage(int id) {
 122   CR_DEFINE_STATIC_LOCAL(std::set<int>, images, ());
 123   if (images.empty()) {
 124     images.insert(kThemeImages, kThemeImages + arraysize(kThemeImages));
 125     images.insert(kAutocompleteImages,
 126                   kAutocompleteImages + arraysize(kAutocompleteImages));
 127
 128     const std::set<int>& buttons =
 129         ThemeProperties::GetTintableToolbarButtons();
 130     images.insert(buttons.begin(), buttons.end());
 131   }
 132
 133   return images.count(id) > 0;
 134 }
 135
 136 // Picks a button tint from a set of background colors. While
 137 // |accent_gdk_color| will usually be the same color through a theme, this
 138 // function will get called with the normal GtkLabel |text_color|/GtkWindow
 139 // |background_color| pair and the GtkEntry |text_color|/|background_color|
 140 // pair. While 3/4 of the time the resulting tint will be the same, themes that
 141 // have a dark window background (with light text) and a light text entry (with
 142 // dark text) will get better icons with this separated out.
 143 void PickButtonTintFromColors(const GdkColor& accent_gdk_color,
 144                               const GdkColor& text_color,
 145                               const GdkColor& background_color,
 146                               color_utils::HSL* tint) {
 147   SkColor accent_color = gfx::GdkColorToSkColor(accent_gdk_color);
 148   color_utils::HSL accent_tint;
 149   color_utils::SkColorToHSL(accent_color, &accent_tint);
 150
 151   color_utils::HSL text_tint;
 152   color_utils::SkColorToHSL(gfx::GdkColorToSkColor(text_color), &text_tint);
 153
 154   color_utils::HSL background_tint;
 155   color_utils::SkColorToHSL(gfx::GdkColorToSkColor(background_color),
 156                             &background_tint);
 157
 158   // If the accent color is gray, then our normal HSL tomfoolery will bring out
 159   // whatever color is oddly dominant (for example, in rgb space [125, 128,
 160   // 125] will tint green instead of gray). Slight differences (+/-10 (4%) to
 161   // all color components) should be interpreted as this color being gray and
 162   // we should switch into a special grayscale mode.
 163   int rb_diff = abs(SkColorGetR(accent_color) - SkColorGetB(accent_color));
 164   int rg_diff = abs(SkColorGetR(accent_color) - SkColorGetG(accent_color));
 165   int bg_diff = abs(SkColorGetB(accent_color) - SkColorGetG(accent_color));
 166   if (rb_diff < 10 && rg_diff < 10 && bg_diff < 10) {
 167     // Our accent is white/gray/black. Only the luminance of the accent color
 168     // matters.
 169     tint->h = -1;
 170
 171     // Use the saturation of the text.
 172     tint->s = text_tint.s;
 173
 174     // Use the luminance of the accent color UNLESS there isn't enough
 175     // luminance contrast between the accent color and the base color.
 176     if (fabs(accent_tint.l - background_tint.l) > 0.3)
 177       tint->l = accent_tint.l;
 178     else
 179       tint->l = text_tint.l;
 180   } else {
 181     // Our accent is a color.
 182     tint->h = accent_tint.h;
 183
 184     // Don't modify the saturation; the amount of color doesn't matter.
 185     tint->s = -1;
 186
 187     // If the text wants us to darken the icon, don't change the luminance (the
 188     // icons are already dark enough). Otherwise, lighten the icon by no more
 189     // than 0.9 since we don't want a pure-white icon even if the text is pure
 190     // white.
 191     if (text_tint.l < 0.5)
 192       tint->l = -1;
 193     else if (text_tint.l <= 0.9)
 194       tint->l = text_tint.l;
 195     else
 196       tint->l = 0.9;
 197   }
 198 }
 199
 200
 201 // Builds and tints the image with |id| to the GtkStateType |state| and
 202 // places the result in |icon_set|.
 203 void BuildIconFromIDRWithColor(int id,
 204                                GtkStyle* style,
 205                                GtkStateType state,
 206                                GtkIconSet* icon_set) {
 207   SkColor color = gfx::GdkColorToSkColor(style->fg[state]);
 208   ui::ResourceBundle& rb = ui::ResourceBundle::GetSharedInstance();
 209   SkBitmap original = rb.GetImageNamed(id).AsBitmap();
 210
 211   SkBitmap fill_color;
 212   fill_color.setConfig(SkBitmap::kARGB_8888_Config,
 213                        original.width(), original.height(), 0);
 214   fill_color.allocPixels();
 215   fill_color.eraseColor(color);
 216   SkBitmap masked = SkBitmapOperations::CreateMaskedBitmap(
 217       fill_color, original);
 218
 219   GtkIconSource* icon = gtk_icon_source_new();
 220   GdkPixbuf* pixbuf = gfx::GdkPixbufFromSkBitmap(masked);
 221   gtk_icon_source_set_pixbuf(icon, pixbuf);
 222   g_object_unref(pixbuf);
 223
 224   gtk_icon_source_set_direction_wildcarded(icon, TRUE);
 225   gtk_icon_source_set_size_wildcarded(icon, TRUE);
 226
 227   gtk_icon_source_set_state(icon, state);
 228   // All fields default to wildcarding being on and setting a property doesn't
 229   // turn off wildcarding. You need to do this yourself. This is stated once in
 230   // the documentation in the gtk_icon_source_new() function, and no where else.
 231   gtk_icon_source_set_state_wildcarded(
 232       icon, state == GTK_STATE_NORMAL);
 233
 234   gtk_icon_set_add_source(icon_set, icon);
 235   gtk_icon_source_free(icon);
 236 }
 237
 238 // Applies an HSL shift to a GdkColor (instead of an SkColor)
 239 void GdkColorHSLShift(const color_utils::HSL& shift, GdkColor* frame_color) {
 240   SkColor shifted = color_utils::HSLShift(gfx::GdkColorToSkColor(*frame_color),
 241                                                                  shift);
 242   frame_color->pixel = 0;
 243   frame_color->red = SkColorGetR(shifted) * ui::kSkiaToGDKMultiplier;
 244   frame_color->green = SkColorGetG(shifted) * ui::kSkiaToGDKMultiplier;
 245   frame_color->blue = SkColorGetB(shifted) * ui::kSkiaToGDKMultiplier;
 246 }
 247
 248 }  // namespace
 249
 250 GtkWidget* GtkThemeService::icon_widget_ = NULL;
 251 base::LazyInstance<gfx::Image> GtkThemeService::default_folder_icon_ =
 252     LAZY_INSTANCE_INITIALIZER;
 253 base::LazyInstance<gfx::Image> GtkThemeService::default_bookmark_icon_ =
 254     LAZY_INSTANCE_INITIALIZER;
 255
 256 // static
 257 GtkThemeService* GtkThemeService::GetFrom(Profile* profile) {
 258   return static_cast<GtkThemeService*>(
 259       ThemeServiceFactory::GetForProfile(profile));
 260 }
 261
 262 GtkThemeService::GtkThemeService()
 263     : ThemeService(),
 264       use_gtk_(false),
 265       fake_window_(gtk_window_new(GTK_WINDOW_TOPLEVEL)),
 266       fake_frame_(chrome_gtk_frame_new()),
 267       signals_(new ui::GtkSignalRegistrar),
 268       fullscreen_icon_set_(NULL) {
 269   fake_label_.Own(gtk_label_new(""));
 270   fake_entry_.Own(gtk_entry_new());
 271   fake_menu_item_.Own(gtk_menu_item_new());
 272
 273   // Only realized widgets receive style-set notifications, which we need to
 274   // broadcast new theme images and colors. Only realized widgets have style
 275   // properties, too, which we query for some colors.
 276   gtk_widget_realize(fake_frame_);
 277   gtk_widget_realize(fake_window_);
 278   signals_->Connect(fake_frame_, "style-set",
 279                     G_CALLBACK(&OnStyleSetThunk), this);
 280 }
 281
 282 GtkThemeService::~GtkThemeService() {
 283   gtk_widget_destroy(fake_window_);
 284   gtk_widget_destroy(fake_frame_);
 285   fake_label_.Destroy();
 286   fake_entry_.Destroy();
 287   fake_menu_item_.Destroy();
 288
 289   FreeIconSets();
 290
 291   // We have to call this because FreePlatformCached() in ~ThemeService
 292   // doesn't call the right virutal FreePlatformCaches.
 293   FreePlatformCaches();
 294 }
 295
 296 void GtkThemeService::Init(Profile* profile) {
 297   registrar_.Init(profile->GetPrefs());
 298   registrar_.Add(prefs::kUsesSystemTheme,
 299                  base::Bind(&GtkThemeService::OnUsesSystemThemeChanged,
 300                             base::Unretained(this)));
 301   ThemeService::Init(profile);
 302 }
 303
 304 gfx::ImageSkia* GtkThemeService::GetImageSkiaNamed(int id) const {
 305   // TODO(pkotwicz): Remove this const cast.  The gfx::Image interface returns
 306   // its images const. GetImageSkiaNamed() also should but has many callsites.
 307   return const_cast<gfx::ImageSkia*>(GetImageNamed(id).ToImageSkia());
 308 }
 309
 310 gfx::Image GtkThemeService::GetImageNamed(int id) const {
 311   // Try to get our cached version:
 312   ImageCache::const_iterator it = gtk_images_.find(id);
 313   if (it != gtk_images_.end())
 314     return *it->second;
 315
 316   if (use_gtk_ && IsOverridableImage(id)) {
 317     gfx::Image* image = new gfx::Image(gfx::ImageSkia::CreateFrom1xBitmap(
 318         GenerateGtkThemeBitmap(id)));
 319     gtk_images_[id] = image;
 320     return *image;
 321   }
 322
 323   return ThemeService::GetImageNamed(id);
 324 }
 325
 326 SkColor GtkThemeService::GetColor(int id) const {
 327   if (use_gtk_) {
 328     ColorMap::const_iterator it = colors_.find(id);
 329     if (it != colors_.end())
 330       return it->second;
 331   }
 332
 333   return ThemeService::GetColor(id);
 334 }
 335
 336 bool GtkThemeService::HasCustomImage(int id) const {
 337   if (use_gtk_)
 338     return IsOverridableImage(id);
 339
 340   return ThemeService::HasCustomImage(id);
 341 }
 342
 343 void GtkThemeService::InitThemesFor(content::NotificationObserver* observer) {
 344   observer->Observe(chrome::NOTIFICATION_BROWSER_THEME_CHANGED,
 345                     content::Source<ThemeService>(this),
 346                     content::NotificationService::NoDetails());
 347 }
 348
 349 void GtkThemeService::SetTheme(const extensions::Extension* extension) {
 350   profile()->GetPrefs()->SetBoolean(prefs::kUsesSystemTheme, false);
 351   use_gtk_ = false;
 352   LoadDefaultValues();
 353   ThemeService::SetTheme(extension);
 354 }
 355
 356 void GtkThemeService::UseDefaultTheme() {
 357   profile()->GetPrefs()->SetBoolean(prefs::kUsesSystemTheme, false);
 358   use_gtk_ = false;
 359   LoadDefaultValues();
 360   ThemeService::UseDefaultTheme();
 361 }
 362
 363 void GtkThemeService::SetNativeTheme() {
 364   profile()->GetPrefs()->SetBoolean(prefs::kUsesSystemTheme, true);
 365   use_gtk_ = true;
 366   ClearAllThemeData();
 367   LoadGtkValues();
 368   NotifyThemeChanged();
 369 }
 370
 371 bool GtkThemeService::UsingDefaultTheme() const {
 372   return !use_gtk_ && ThemeService::UsingDefaultTheme();
 373 }
 374
 375 void GtkThemeService::SetCustomDefaultTheme(
 376     scoped_refptr<CustomThemeSupplier> theme_supplier) {
 377   profile()->GetPrefs()->SetBoolean(prefs::kUsesSystemTheme, false);
 378   use_gtk_ = false;
 379   LoadDefaultValues();
 380   ThemeService::SetCustomDefaultTheme(theme_supplier);
 381 }
 382
 383 bool GtkThemeService::ShouldInitWithNativeTheme() const {
 384   return profile()->GetPrefs()->GetBoolean(prefs::kUsesSystemTheme);
 385 }
 386
 387 bool GtkThemeService::UsingNativeTheme() const {
 388   return use_gtk_;
 389 }
 390
 391 GtkWidget* GtkThemeService::BuildChromeButton() {
 392   GtkWidget* button = HoverControllerGtk::CreateChromeButton();
 393   gtk_chrome_button_set_use_gtk_rendering(GTK_CHROME_BUTTON(button), use_gtk_);
 394   chrome_buttons_.push_back(button);
 395
 396   signals_->Connect(button, "destroy", G_CALLBACK(OnDestroyChromeButtonThunk),
 397                     this);
 398   return button;
 399 }
 400
 401 GtkWidget* GtkThemeService::BuildChromeLinkButton(const std::string& text) {
 402   GtkWidget* link_button = gtk_chrome_link_button_new(text.c_str());
 403   gtk_chrome_link_button_set_use_gtk_theme(
 404       GTK_CHROME_LINK_BUTTON(link_button),
 405       use_gtk_);
 406   link_buttons_.push_back(link_button);
 407
 408   signals_->Connect(link_button, "destroy",
 409                     G_CALLBACK(OnDestroyChromeLinkButtonThunk), this);
 410
 411   return link_button;
 412 }
 413
 414 GtkWidget* GtkThemeService::BuildLabel(const std::string& text,
 415                                        const GdkColor& color) {
 416   GtkWidget* label = gtk_label_new(text.empty() ? NULL : text.c_str());
 417   if (!use_gtk_)
 418     gtk_util::SetLabelColor(label, &color);
 419   labels_.insert(std::make_pair(label, color));
 420
 421   signals_->Connect(label, "destroy", G_CALLBACK(OnDestroyLabelThunk), this);
 422
 423   return label;
 424 }
 425
 426 GtkWidget* GtkThemeService::CreateToolbarSeparator() {
 427   GtkWidget* separator = gtk_vseparator_new();
 428   GtkWidget* alignment = gtk_alignment_new(0, 0, 1, 1);
 429   gtk_alignment_set_padding(GTK_ALIGNMENT(alignment),
 430       kSeparatorPadding, kSeparatorPadding, kSeparatorPadding, 0);
 431   gtk_container_add(GTK_CONTAINER(alignment), separator);
 432
 433   signals_->Connect(separator, "expose-event",
 434                     G_CALLBACK(OnSeparatorExposeThunk), this);
 435   return alignment;
 436 }
 437
 438 GdkColor GtkThemeService::GetGdkColor(int id) const {
 439   return gfx::SkColorToGdkColor(GetColor(id));
 440 }
 441
 442 GdkColor GtkThemeService::GetBorderColor() const {
 443   GtkStyle* style = gtk_rc_get_style(fake_window_);
 444
 445   GdkColor text;
 446   GdkColor bg;
 447   if (use_gtk_) {
 448     text = style->text[GTK_STATE_NORMAL];
 449     bg = style->bg[GTK_STATE_NORMAL];
 450   } else {
 451     text = GetGdkColor(ThemeProperties::COLOR_BOOKMARK_TEXT);
 452     bg = GetGdkColor(ThemeProperties::COLOR_TOOLBAR);
 453   }
 454
 455   // Creates a weighted average between the text and base color where
 456   // the base color counts more than once.
 457   GdkColor color;
 458   color.pixel = 0;
 459   color.red = (text.red + (bg.red * kBgWeight)) / (1 + kBgWeight);
 460   color.green = (text.green + (bg.green * kBgWeight)) / (1 + kBgWeight);
 461   color.blue = (text.blue + (bg.blue * kBgWeight)) / (1 + kBgWeight);
 462
 463   return color;
 464 }
 465
 466 GtkIconSet* GtkThemeService::GetIconSetForId(int id) const {
 467   if (id == IDR_FULLSCREEN_MENU_BUTTON)
 468     return fullscreen_icon_set_;
 469
 470   return NULL;
 471 }
 472
 473 void GtkThemeService::GetScrollbarColors(GdkColor* thumb_active_color,
 474                                          GdkColor* thumb_inactive_color,
 475                                          GdkColor* track_color) {
 476   GdkColor* theme_thumb_active = NULL;
 477   GdkColor* theme_thumb_inactive = NULL;
 478   GdkColor* theme_trough_color = NULL;
 479   gtk_widget_style_get(GTK_WIDGET(fake_frame_),
 480                        "scrollbar-slider-prelight-color", &theme_thumb_active,
 481                        "scrollbar-slider-normal-color", &theme_thumb_inactive,
 482                        "scrollbar-trough-color", &theme_trough_color,
 483                        NULL);
 484
 485   // Ask the theme if the theme specifies all the scrollbar colors and short
 486   // circuit the expensive painting/compositing if we have all of them.
 487   if (theme_thumb_active && theme_thumb_inactive && theme_trough_color) {
 488     *thumb_active_color = *theme_thumb_active;
 489     *thumb_inactive_color = *theme_thumb_inactive;
 490     *track_color = *theme_trough_color;
 491     gdk_color_free(theme_thumb_active);
 492     gdk_color_free(theme_thumb_inactive);
 493     gdk_color_free(theme_trough_color);
 494     return;
 495   }
 496
 497   // Create window containing scrollbar elements
 498   GtkWidget* window    = gtk_window_new(GTK_WINDOW_POPUP);
 499   GtkWidget* fixed     = gtk_fixed_new();
 500   GtkWidget* scrollbar = gtk_hscrollbar_new(NULL);
 501   gtk_container_add(GTK_CONTAINER(window), fixed);
 502   gtk_container_add(GTK_CONTAINER(fixed),  scrollbar);
 503   gtk_widget_realize(window);
 504   gtk_widget_realize(scrollbar);
 505
 506   // Draw scrollbar thumb part and track into offscreen image
 507   const int kWidth  = 100;
 508   const int kHeight = 20;
 509   GtkStyle*  style  = gtk_rc_get_style(scrollbar);
 510   GdkWindow* gdk_window = gtk_widget_get_window(window);
 511   GdkPixmap* pm     = gdk_pixmap_new(gdk_window, kWidth, kHeight, -1);
 512   GdkRectangle rect = { 0, 0, kWidth, kHeight };
 513   unsigned char data[3 * kWidth * kHeight];
 514   for (int i = 0; i < 3; ++i) {
 515     if (i < 2) {
 516       // Thumb part
 517       gtk_paint_slider(style, pm,
 518                        i == 0 ? GTK_STATE_PRELIGHT : GTK_STATE_NORMAL,
 519                        GTK_SHADOW_OUT, &rect, scrollbar, "slider", 0, 0,
 520                        kWidth, kHeight, GTK_ORIENTATION_HORIZONTAL);
 521     } else {
 522       // Track
 523       gtk_paint_box(style, pm, GTK_STATE_ACTIVE, GTK_SHADOW_IN, &rect,
 524                     scrollbar, "trough-upper", 0, 0, kWidth, kHeight);
 525     }
 526     GdkPixbuf* pb = gdk_pixbuf_new_from_data(data, GDK_COLORSPACE_RGB,
 527                                              FALSE, 8, kWidth, kHeight,
 528                                              3 * kWidth, 0, 0);
 529     gdk_pixbuf_get_from_drawable(pb, pm, NULL, 0, 0, 0, 0, kWidth, kHeight);
 530
 531     // Sample pixels
 532     int components[3] = { 0 };
 533     for (int y = 2; y < kHeight - 2; ++y) {
 534       for (int c = 0; c < 3; ++c) {
 535         // Sample a vertical slice of pixels at about one-thirds from the
 536         // left edge. This allows us to avoid any fixed graphics that might be
 537         // located at the edges or in the center of the scrollbar.
 538         // Each pixel is made up of a red, green, and blue component; taking up
 539         // a total of three bytes.
 540         components[c] += data[3 * (kWidth / 3 + y * kWidth) + c];
 541       }
 542     }
 543     GdkColor* color = i == 0 ? thumb_active_color :
 544                       i == 1 ? thumb_inactive_color :
 545                                track_color;
 546     color->pixel = 0;
 547     // We sampled pixels across the full height of the image, ignoring a two
 548     // pixel border. In some themes, the border has a completely different
 549     // color which we do not want to factor into our average color computation.
 550     //
 551     // We now need to scale the colors from the 0..255 range, to the wider
 552     // 0..65535 range, and we need to actually compute the average color; so,
 553     // we divide by the total number of pixels in the sample.
 554     color->red   = components[0] * 65535 / (255 * (kHeight - 4));
 555     color->green = components[1] * 65535 / (255 * (kHeight - 4));
 556     color->blue  = components[2] * 65535 / (255 * (kHeight - 4));
 557
 558     g_object_unref(pb);
 559   }
 560   g_object_unref(pm);
 561
 562   gtk_widget_destroy(window);
 563
 564   // Override any of the default colors with ones that were specified by the
 565   // theme.
 566   if (theme_thumb_active) {
 567     *thumb_active_color = *theme_thumb_active;
 568     gdk_color_free(theme_thumb_active);
 569   }
 570
 571   if (theme_thumb_inactive) {
 572     *thumb_inactive_color = *theme_thumb_inactive;
 573     gdk_color_free(theme_thumb_inactive);
 574   }
 575
 576   if (theme_trough_color) {
 577     *track_color = *theme_trough_color;
 578     gdk_color_free(theme_trough_color);
 579   }
 580 }
 581
 582 // static
 583 gfx::Image GtkThemeService::GetFolderIcon(bool native) {
 584   if (native) {
 585     if (!icon_widget_)
 586       icon_widget_ = gtk_window_new(GTK_WINDOW_TOPLEVEL);
 587
 588     if (default_folder_icon_.Get().IsEmpty()) {
 589       // This seems to leak.
 590       GdkPixbuf* pixbuf = gtk_widget_render_icon(
 591           icon_widget_, GTK_STOCK_DIRECTORY, GTK_ICON_SIZE_MENU, NULL);
 592       if (pixbuf)
 593         default_folder_icon_.Get() = gfx::Image(pixbuf);
 594     }
 595     if (!default_folder_icon_.Get().IsEmpty())
 596       return default_folder_icon_.Get();
 597   }
 598
 599   return ui::ResourceBundle::GetSharedInstance().GetNativeImageNamed(
 600       IDR_BOOKMARK_BAR_FOLDER);
 601 }
 602
 603 // static
 604 gfx::Image GtkThemeService::GetDefaultFavicon(bool native) {
 605   if (native) {
 606     if (!icon_widget_)
 607       icon_widget_ = gtk_window_new(GTK_WINDOW_TOPLEVEL);
 608
 609     if (default_bookmark_icon_.Get().IsEmpty()) {
 610       // This seems to leak.
 611       GdkPixbuf* pixbuf = gtk_widget_render_icon(
 612           icon_widget_, GTK_STOCK_FILE, GTK_ICON_SIZE_MENU, NULL);
 613       if (pixbuf)
 614         default_bookmark_icon_.Get() = gfx::Image(pixbuf);
 615     }
 616     if (!default_bookmark_icon_.Get().IsEmpty())
 617       return default_bookmark_icon_.Get();
 618   }
 619
 620   return ui::ResourceBundle::GetSharedInstance().GetNativeImageNamed(
 621       IDR_DEFAULT_FAVICON);
 622 }
 623
 624 // static
 625 bool GtkThemeService::DefaultUsesSystemTheme() {
 626   scoped_ptr<base::Environment> env(base::Environment::Create());
 627
 628   switch (base::nix::GetDesktopEnvironment(env.get())) {
 629     case base::nix::DESKTOP_ENVIRONMENT_GNOME:
 630     case base::nix::DESKTOP_ENVIRONMENT_UNITY:
 631     case base::nix::DESKTOP_ENVIRONMENT_XFCE:
 632       return true;
 633     case base::nix::DESKTOP_ENVIRONMENT_KDE3:
 634     case base::nix::DESKTOP_ENVIRONMENT_KDE4:
 635     case base::nix::DESKTOP_ENVIRONMENT_OTHER:
 636       return false;
 637   }
 638   // Unless GetDesktopEnvironment() badly misbehaves, this should never happen.
 639   NOTREACHED();
 640   return false;
 641 }
 642
 643 void GtkThemeService::LoadThemePrefs() {
 644   // Initialize the values sent to webkit with the default values.
 645   // ThemeService::LoadThemePrefs() will replace them with values for the native
 646   // gtk theme if necessary.
 647   LoadDefaultValues();
 648
 649   // This takes care of calling SetNativeTheme() if necessary.
 650   ThemeService::LoadThemePrefs();
 651
 652   SetXDGIconTheme();
 653   RebuildMenuIconSets();
 654 }
 655
 656 void GtkThemeService::NotifyThemeChanged() {
 657   if (!ready_)
 658     return;
 659
 660   ThemeService::NotifyThemeChanged();
 661
 662   // Notify all GtkChromeButtons of their new rendering mode:
 663   for (std::vector<GtkWidget*>::iterator it = chrome_buttons_.begin();
 664        it != chrome_buttons_.end(); ++it) {
 665     gtk_chrome_button_set_use_gtk_rendering(
 666         GTK_CHROME_BUTTON(*it), use_gtk_);
 667   }
 668
 669   for (std::vector<GtkWidget*>::iterator it = link_buttons_.begin();
 670        it != link_buttons_.end(); ++it) {
 671     gtk_chrome_link_button_set_use_gtk_theme(
 672         GTK_CHROME_LINK_BUTTON(*it), use_gtk_);
 673   }
 674
 675   for (std::map<GtkWidget*, GdkColor>::iterator it = labels_.begin();
 676        it != labels_.end(); ++it) {
 677     const GdkColor* color = use_gtk_ ? NULL : &it->second;
 678     gtk_util::SetLabelColor(it->first, color);
 679   }
 680
 681   for (chrome::BrowserIterator it; !it.done(); it.Next()) {
 682     Browser* browser = *it;
 683     if (!browser->window())
 684       continue;
 685     GtkWindow* window = browser->window()->GetNativeWindow();
 686     gtk_util::SetDefaultWindowIcon(window);
 687     gtk_util::SetWindowIcon(window, browser->profile());
 688   }
 689 }
 690
 691 void GtkThemeService::FreePlatformCaches() {
 692   colors_.clear();
 693   tints_.clear();
 694   ThemeService::FreePlatformCaches();
 695   STLDeleteValues(&gtk_images_);
 696 }
 697
 698 void GtkThemeService::OnStyleSet(GtkWidget* widget,
 699                                  GtkStyle* previous_style) {
 700   default_folder_icon_.Get() = gfx::Image();
 701   default_bookmark_icon_.Get() = gfx::Image();
 702
 703   if (profile()->GetPrefs()->GetBoolean(prefs::kUsesSystemTheme)) {
 704     ClearAllThemeData();
 705     LoadGtkValues();
 706     NotifyThemeChanged();
 707   }
 708
 709   RebuildMenuIconSets();
 710 }
 711
 712 void GtkThemeService::SetXDGIconTheme() {
 713   gchar* gtk_theme_name;
 714   g_object_get(gtk_settings_get_default(),
 715                "gtk-icon-theme-name",
 716                &gtk_theme_name, NULL);
 717   base::nix::SetIconThemeName(gtk_theme_name);
 718   g_free(gtk_theme_name);
 719 }
 720
 721 void GtkThemeService::LoadGtkValues() {
 722   // Before we start setting images and values, we have to clear out old, stale
 723   // values. (If we don't do this, we'll regress startup time in the case where
 724   // someone installs a heavyweight theme, then goes back to GTK.)
 725   profile()->GetPrefs()->ClearPref(prefs::kCurrentThemeImages);
 726
 727   GtkStyle* frame_style = gtk_rc_get_style(fake_frame_);
 728
 729   GtkStyle* window_style = gtk_rc_get_style(fake_window_);
 730   SetThemeColorFromGtk(ThemeProperties::COLOR_CONTROL_BACKGROUND,
 731                        &window_style->bg[GTK_STATE_NORMAL]);
 732
 733   GdkColor toolbar_color = window_style->bg[GTK_STATE_NORMAL];
 734   SetThemeColorFromGtk(ThemeProperties::COLOR_TOOLBAR, &toolbar_color);
 735
 736   GdkColor button_color = window_style->bg[GTK_STATE_SELECTED];
 737   SetThemeTintFromGtk(ThemeProperties::TINT_BUTTONS, &button_color);
 738
 739   GtkStyle* label_style = gtk_rc_get_style(fake_label_.get());
 740   GdkColor label_color = label_style->fg[GTK_STATE_NORMAL];
 741   SetThemeColorFromGtk(ThemeProperties::COLOR_TAB_TEXT, &label_color);
 742   SetThemeColorFromGtk(ThemeProperties::COLOR_BOOKMARK_TEXT, &label_color);
 743
 744   // Build the various icon tints.
 745   GetNormalButtonTintHSL(&button_tint_);
 746   GetNormalEntryForegroundHSL(&entry_tint_);
 747   GetSelectedEntryForegroundHSL(&selected_entry_tint_);
 748   GdkColor frame_color = BuildFrameColors(frame_style);
 749
 750   // The inactive frame color never occurs naturally in the theme, as it is a
 751   // tinted version of |frame_color|. We generate another color based on the
 752   // background tab color, with the lightness and saturation moved in the
 753   // opposite direction. (We don't touch the hue, since there should be subtle
 754   // hints of the color in the text.)
 755   color_utils::HSL inactive_tab_text_hsl =
 756       tints_[ThemeProperties::TINT_BACKGROUND_TAB];
 757   if (inactive_tab_text_hsl.l < 0.5)
 758     inactive_tab_text_hsl.l = kDarkInactiveLuminance;
 759   else
 760     inactive_tab_text_hsl.l = kLightInactiveLuminance;
 761
 762   if (inactive_tab_text_hsl.s < 0.5)
 763     inactive_tab_text_hsl.s = kHeavyInactiveSaturation;
 764   else
 765     inactive_tab_text_hsl.s = kLightInactiveSaturation;
 766
 767   colors_[ThemeProperties::COLOR_BACKGROUND_TAB_TEXT] =
 768       color_utils::HSLToSkColor(inactive_tab_text_hsl, 255);
 769
 770   // We pick the text and background colors for the NTP out of the colors for a
 771   // GtkEntry. We do this because GtkEntries background color is never the same
 772   // as |toolbar_color|, is usually a white, and when it isn't a white,
 773   // provides sufficient contrast to |toolbar_color|. Try this out with
 774   // Darklooks, HighContrastInverse or ThinIce.
 775   GtkStyle* entry_style = gtk_rc_get_style(fake_entry_.get());
 776   GdkColor ntp_background = entry_style->base[GTK_STATE_NORMAL];
 777   GdkColor ntp_foreground = entry_style->text[GTK_STATE_NORMAL];
 778   SetThemeColorFromGtk(ThemeProperties::COLOR_NTP_BACKGROUND,
 779                        &ntp_background);
 780   SetThemeColorFromGtk(ThemeProperties::COLOR_NTP_TEXT,
 781                        &ntp_foreground);
 782
 783   // The NTP header is the color that surrounds the current active thumbnail on
 784   // the NTP, and acts as the border of the "Recent Links" box. It would be
 785   // awesome if they were separated so we could use GetBorderColor() for the
 786   // border around the "Recent Links" section, but matching the frame color is
 787   // more important.
 788   SetThemeColorFromGtk(ThemeProperties::COLOR_NTP_HEADER,
 789                        &frame_color);
 790   SetThemeColorFromGtk(ThemeProperties::COLOR_NTP_SECTION,
 791                        &toolbar_color);
 792   SetThemeColorFromGtk(ThemeProperties::COLOR_NTP_SECTION_TEXT,
 793                        &label_color);
 794
 795   // Override the link color if the theme provides it.
 796   const GdkColor* link_color = NULL;
 797   gtk_widget_style_get(GTK_WIDGET(fake_window_),
 798                        "link-color", &link_color, NULL);
 799
 800   bool is_default_link_color = false;
 801   if (!link_color) {
 802     link_color = &kDefaultLinkColor;
 803     is_default_link_color = true;
 804   }
 805
 806   SetThemeColorFromGtk(ThemeProperties::COLOR_NTP_LINK,
 807                        link_color);
 808   SetThemeColorFromGtk(ThemeProperties::COLOR_NTP_LINK_UNDERLINE,
 809                        link_color);
 810   SetThemeColorFromGtk(ThemeProperties::COLOR_NTP_SECTION_LINK,
 811                        link_color);
 812   SetThemeColorFromGtk(ThemeProperties::COLOR_NTP_SECTION_LINK_UNDERLINE,
 813                        link_color);
 814
 815   if (!is_default_link_color)
 816     gdk_color_free(const_cast<GdkColor*>(link_color));
 817
 818   // Generate the colors that we pass to WebKit.
 819   focus_ring_color_ = gfx::GdkColorToSkColor(frame_color);
 820   GdkColor thumb_active_color, thumb_inactive_color, track_color;
 821   GtkThemeService::GetScrollbarColors(&thumb_active_color,
 822                                       &thumb_inactive_color,
 823                                       &track_color);
 824   thumb_active_color_ = gfx::GdkColorToSkColor(thumb_active_color);
 825   thumb_inactive_color_ = gfx::GdkColorToSkColor(thumb_inactive_color);
 826   track_color_ = gfx::GdkColorToSkColor(track_color);
 827
 828   // Some GTK themes only define the text selection colors on the GtkEntry
 829   // class, so we need to use that for getting selection colors.
 830   active_selection_bg_color_ =
 831       gfx::GdkColorToSkColor(entry_style->base[GTK_STATE_SELECTED]);
 832   active_selection_fg_color_ =
 833       gfx::GdkColorToSkColor(entry_style->text[GTK_STATE_SELECTED]);
 834   inactive_selection_bg_color_ =
 835       gfx::GdkColorToSkColor(entry_style->base[GTK_STATE_ACTIVE]);
 836   inactive_selection_fg_color_ =
 837       gfx::GdkColorToSkColor(entry_style->text[GTK_STATE_ACTIVE]);
 838   location_bar_bg_color_ =
 839       gfx::GdkColorToSkColor(entry_style->base[GTK_STATE_NORMAL]);
 840   location_bar_text_color_ =
 841       gfx::GdkColorToSkColor(entry_style->text[GTK_STATE_NORMAL]);
 842 }
 843
 844 GdkColor GtkThemeService::BuildFrameColors(GtkStyle* frame_style) {
 845   GdkColor* theme_frame = NULL;
 846   GdkColor* theme_inactive_frame = NULL;
 847   GdkColor* theme_incognito_frame = NULL;
 848   GdkColor* theme_incognito_inactive_frame = NULL;
 849   gtk_widget_style_get(GTK_WIDGET(fake_frame_),
 850                        "frame-color", &theme_frame,
 851                        "inactive-frame-color", &theme_inactive_frame,
 852                        "incognito-frame-color", &theme_incognito_frame,
 853                        "incognito-inactive-frame-color",
 854                        &theme_incognito_inactive_frame,
 855                        NULL);
 856
 857   GdkColor frame_color = BuildAndSetFrameColor(
 858       &frame_style->bg[GTK_STATE_SELECTED],
 859       theme_frame,
 860       kDefaultFrameShift,
 861       ThemeProperties::COLOR_FRAME,
 862       ThemeProperties::TINT_FRAME);
 863   if (theme_frame)
 864     gdk_color_free(theme_frame);
 865   SetThemeTintFromGtk(ThemeProperties::TINT_BACKGROUND_TAB, &frame_color);
 866
 867   BuildAndSetFrameColor(
 868       &frame_style->bg[GTK_STATE_INSENSITIVE],
 869       theme_inactive_frame,
 870       kDefaultFrameShift,
 871       ThemeProperties::COLOR_FRAME_INACTIVE,
 872       ThemeProperties::TINT_FRAME_INACTIVE);
 873   if (theme_inactive_frame)
 874     gdk_color_free(theme_inactive_frame);
 875
 876   BuildAndSetFrameColor(
 877       &frame_color,
 878       theme_incognito_frame,
 879       ThemeProperties::GetDefaultTint(
 880           ThemeProperties::TINT_FRAME_INCOGNITO),
 881       ThemeProperties::COLOR_FRAME_INCOGNITO,
 882       ThemeProperties::TINT_FRAME_INCOGNITO);
 883   if (theme_incognito_frame)
 884     gdk_color_free(theme_incognito_frame);
 885
 886   BuildAndSetFrameColor(
 887       &frame_color,
 888       theme_incognito_inactive_frame,
 889       ThemeProperties::GetDefaultTint(
 890           ThemeProperties::TINT_FRAME_INCOGNITO_INACTIVE),
 891       ThemeProperties::COLOR_FRAME_INCOGNITO_INACTIVE,
 892       ThemeProperties::TINT_FRAME_INCOGNITO_INACTIVE);
 893   if (theme_incognito_inactive_frame)
 894     gdk_color_free(theme_incognito_inactive_frame);
 895
 896   return frame_color;
 897 }
 898
 899 void GtkThemeService::LoadDefaultValues() {
 900   focus_ring_color_ = SkColorSetARGB(255, 229, 151, 0);
 901   thumb_active_color_ = SkColorSetRGB(244, 244, 244);
 902   thumb_inactive_color_ = SkColorSetRGB(234, 234, 234);
 903   track_color_ = SkColorSetRGB(211, 211, 211);
 904
 905   active_selection_bg_color_ = SkColorSetRGB(30, 144, 255);
 906   active_selection_fg_color_ = SK_ColorWHITE;
 907   inactive_selection_bg_color_ = SkColorSetRGB(200, 200, 200);
 908   inactive_selection_fg_color_ = SkColorSetRGB(50, 50, 50);
 909 }
 910
 911 void GtkThemeService::RebuildMenuIconSets() {
 912   FreeIconSets();
 913
 914   GtkStyle* style = gtk_rc_get_style(fake_menu_item_.get());
 915
 916   fullscreen_icon_set_ = gtk_icon_set_new();
 917   BuildIconFromIDRWithColor(IDR_FULLSCREEN_MENU_BUTTON,
 918                             style,
 919                             GTK_STATE_PRELIGHT,
 920                             fullscreen_icon_set_);
 921   BuildIconFromIDRWithColor(IDR_FULLSCREEN_MENU_BUTTON,
 922                             style,
 923                             GTK_STATE_NORMAL,
 924                             fullscreen_icon_set_);
 925 }
 926
 927 void GtkThemeService::SetThemeColorFromGtk(int id, const GdkColor* color) {
 928   colors_[id] = gfx::GdkColorToSkColor(*color);
 929 }
 930
 931 void GtkThemeService::SetThemeTintFromGtk(int id, const GdkColor* color) {
 932   color_utils::HSL default_tint = ThemeProperties::GetDefaultTint(id);
 933   color_utils::HSL hsl;
 934   color_utils::SkColorToHSL(gfx::GdkColorToSkColor(*color), &hsl);
 935
 936   if (default_tint.s != -1)
 937     hsl.s = default_tint.s;
 938
 939   if (default_tint.l != -1)
 940     hsl.l = default_tint.l;
 941
 942   tints_[id] = hsl;
 943 }
 944
 945 GdkColor GtkThemeService::BuildAndSetFrameColor(const GdkColor* base,
 946                                                 const GdkColor* gtk_base,
 947                                                 const color_utils::HSL& tint,
 948                                                 int color_id,
 949                                                 int tint_id) {
 950   GdkColor out_color = *base;
 951   if (gtk_base) {
 952     // The theme author specified a color to use, use it without modification.
 953     out_color = *gtk_base;
 954   } else {
 955     // Tint the basic color since this is a heuristic color instead of one
 956     // specified by the theme author.
 957     GdkColorHSLShift(tint, &out_color);
 958   }
 959   SetThemeColorFromGtk(color_id, &out_color);
 960   SetThemeTintFromGtk(tint_id, &out_color);
 961
 962   return out_color;
 963 }
 964
 965 void GtkThemeService::FreeIconSets() {
 966   if (fullscreen_icon_set_) {
 967     gtk_icon_set_unref(fullscreen_icon_set_);
 968     fullscreen_icon_set_ = NULL;
 969   }
 970 }
 971
 972 SkBitmap GtkThemeService::GenerateGtkThemeBitmap(int id) const {
 973   switch (id) {
 974     case IDR_THEME_TOOLBAR: {
 975       GtkStyle* style = gtk_rc_get_style(fake_window_);
 976       GdkColor* color = &style->bg[GTK_STATE_NORMAL];
 977       SkBitmap bitmap;
 978       bitmap.setConfig(SkBitmap::kARGB_8888_Config,
 979                        kToolbarImageWidth, kToolbarImageHeight);
 980       bitmap.allocPixels();
 981       bitmap.eraseRGB(color->red >> 8, color->green >> 8, color->blue >> 8);
 982       return bitmap;
 983     }
 984     case IDR_THEME_TAB_BACKGROUND:
 985       return GenerateTabImage(IDR_THEME_FRAME);
 986     case IDR_THEME_TAB_BACKGROUND_INCOGNITO:
 987       return GenerateTabImage(IDR_THEME_FRAME_INCOGNITO);
 988     case IDR_THEME_FRAME:
 989       return GenerateFrameImage(ThemeProperties::COLOR_FRAME,
 990                                 "frame-gradient-color");
 991     case IDR_THEME_FRAME_INACTIVE:
 992       return GenerateFrameImage(ThemeProperties::COLOR_FRAME_INACTIVE,
 993                                 "inactive-frame-gradient-color");
 994     case IDR_THEME_FRAME_INCOGNITO:
 995       return GenerateFrameImage(ThemeProperties::COLOR_FRAME_INCOGNITO,
 996                                 "incognito-frame-gradient-color");
 997     case IDR_THEME_FRAME_INCOGNITO_INACTIVE: {
 998       return GenerateFrameImage(
 999           ThemeProperties::COLOR_FRAME_INCOGNITO_INACTIVE,
1000           "incognito-inactive-frame-gradient-color");
1001     }
1002     // Icons that sit inside the omnibox shouldn't receive TINT_BUTTONS and
1003     // instead should tint based on the foreground text entry color in GTK+
1004     // mode because some themes that try to be dark *and* light have very
1005     // different colors between the omnibox and the normal background area.
1006     // TODO(erg): Decide what to do about other icons that appear in the
1007     // omnibox, e.g. content settings icons.
1008     case IDR_OMNIBOX_EXTENSION_APP:
1009     case IDR_OMNIBOX_HTTP:
1010     case IDR_OMNIBOX_SEARCH:
1011     case IDR_OMNIBOX_STAR:
1012     case IDR_OMNIBOX_TTS: {
1013       return GenerateTintedIcon(id, entry_tint_);
1014     }
1015     // In GTK mode, the dark versions of the omnibox icons only ever appear in
1016     // the autocomplete popup and only against the current theme's GtkEntry
1017     // base[GTK_STATE_SELECTED] color, so tint the icons so they won't collide
1018     // with the selected color.
1019     case IDR_OMNIBOX_EXTENSION_APP_DARK:
1020     case IDR_OMNIBOX_HTTP_DARK:
1021     case IDR_OMNIBOX_SEARCH_DARK:
1022     case IDR_OMNIBOX_STAR_DARK:
1023     case IDR_OMNIBOX_TTS_DARK: {
1024       return GenerateTintedIcon(id, selected_entry_tint_);
1025     }
1026     default: {
1027       return GenerateTintedIcon(id, button_tint_);
1028     }
1029   }
1030 }
1031
1032 SkBitmap GtkThemeService::GenerateFrameImage(
1033     int color_id,
1034     const char* gradient_name) const {
1035   // We use two colors: the main color (passed in) and a lightened version of
1036   // that color (which is supposed to match the light gradient at the top of
1037   // several GTK+ themes, such as Ambiance, Clearlooks or Bluebird).
1038   ColorMap::const_iterator it = colors_.find(color_id);
1039   DCHECK(it != colors_.end());
1040   SkColor base = it->second;
1041
1042   gfx::Canvas canvas(gfx::Size(kToolbarImageWidth, kToolbarImageHeight),
1043       1.0f, true);
1044
1045   int gradient_size;
1046   GdkColor* gradient_top_color = NULL;
1047   gtk_widget_style_get(GTK_WIDGET(fake_frame_),
1048                        "frame-gradient-size", &gradient_size,
1049                        gradient_name, &gradient_top_color,
1050                        NULL);
1051   if (gradient_size) {
1052     SkColor lighter = gradient_top_color ?
1053         gfx::GdkColorToSkColor(*gradient_top_color) :
1054         color_utils::HSLShift(base, kGtkFrameShift);
1055     if (gradient_top_color)
1056       gdk_color_free(gradient_top_color);
1057     skia::RefPtr<SkShader> shader = gfx::CreateGradientShader(
1058         0, gradient_size, lighter, base);
1059     SkPaint paint;
1060     paint.setStyle(SkPaint::kFill_Style);
1061     paint.setAntiAlias(true);
1062     paint.setShader(shader.get());
1063
1064     canvas.DrawRect(gfx::Rect(0, 0, kToolbarImageWidth, gradient_size), paint);
1065   }
1066
1067   canvas.FillRect(gfx::Rect(0, gradient_size, kToolbarImageWidth,
1068                             kToolbarImageHeight - gradient_size), base);
1069   return canvas.ExtractImageRep().sk_bitmap();
1070 }
1071
1072 SkBitmap GtkThemeService::GenerateTabImage(int base_id) const {
1073   SkBitmap base_image = GetImageNamed(base_id).AsBitmap();
1074   SkBitmap bg_tint = SkBitmapOperations::CreateHSLShiftedBitmap(
1075       base_image, GetTint(ThemeProperties::TINT_BACKGROUND_TAB));
1076   return SkBitmapOperations::CreateTiledBitmap(
1077       bg_tint, 0, 0, bg_tint.width(), bg_tint.height());
1078 }
1079
1080 SkBitmap GtkThemeService::GenerateTintedIcon(
1081     int base_id,
1082     const color_utils::HSL& tint) const {
1083   ui::ResourceBundle& rb = ui::ResourceBundle::GetSharedInstance();
1084   return SkBitmapOperations::CreateHSLShiftedBitmap(
1085       rb.GetImageNamed(base_id).AsBitmap(), tint);
1086 }
1087
1088 void GtkThemeService::GetNormalButtonTintHSL(
1089     color_utils::HSL* tint) const {
1090   GtkStyle* window_style = gtk_rc_get_style(fake_window_);
1091   const GdkColor accent_gdk_color = window_style->bg[GTK_STATE_SELECTED];
1092   const GdkColor base_color = window_style->base[GTK_STATE_NORMAL];
1093
1094   GtkStyle* label_style = gtk_rc_get_style(fake_label_.get());
1095   const GdkColor text_color = label_style->fg[GTK_STATE_NORMAL];
1096
1097   PickButtonTintFromColors(accent_gdk_color, text_color, base_color, tint);
1098 }
1099
1100 void GtkThemeService::GetNormalEntryForegroundHSL(
1101     color_utils::HSL* tint) const {
1102   GtkStyle* window_style = gtk_rc_get_style(fake_window_);
1103   const GdkColor accent_gdk_color = window_style->bg[GTK_STATE_SELECTED];
1104
1105   GtkStyle* style = gtk_rc_get_style(fake_entry_.get());
1106   const GdkColor text_color = style->text[GTK_STATE_NORMAL];
1107   const GdkColor base_color = style->base[GTK_STATE_NORMAL];
1108
1109   PickButtonTintFromColors(accent_gdk_color, text_color, base_color, tint);
1110 }
1111
1112 void GtkThemeService::GetSelectedEntryForegroundHSL(
1113     color_utils::HSL* tint) const {
1114   // The simplest of all the tints. We just use the selected text in the entry
1115   // since the icons tinted this way will only be displayed against
1116   // base[GTK_STATE_SELECTED].
1117   GtkStyle* style = gtk_rc_get_style(fake_entry_.get());
1118   const GdkColor color = style->text[GTK_STATE_SELECTED];
1119   color_utils::SkColorToHSL(gfx::GdkColorToSkColor(color), tint);
1120 }
1121
1122 void GtkThemeService::OnDestroyChromeButton(GtkWidget* button) {
1123   std::vector<GtkWidget*>::iterator it =
1124       find(chrome_buttons_.begin(), chrome_buttons_.end(), button);
1125   if (it != chrome_buttons_.end())
1126     chrome_buttons_.erase(it);
1127 }
1128
1129 void GtkThemeService::OnDestroyChromeLinkButton(GtkWidget* button) {
1130   std::vector<GtkWidget*>::iterator it =
1131       find(link_buttons_.begin(), link_buttons_.end(), button);
1132   if (it != link_buttons_.end())
1133     link_buttons_.erase(it);
1134 }
1135
1136 void GtkThemeService::OnDestroyLabel(GtkWidget* button) {
1137   std::map<GtkWidget*, GdkColor>::iterator it = labels_.find(button);
1138   if (it != labels_.end())
1139     labels_.erase(it);
1140 }
1141
1142 gboolean GtkThemeService::OnSeparatorExpose(GtkWidget* widget,
1143                                             GdkEventExpose* event) {
1144   UNSHIPPED_TRACE_EVENT0("ui::gtk", "GtkThemeService::OnSeparatorExpose");
1145   if (UsingNativeTheme())
1146     return FALSE;
1147
1148   cairo_t* cr = gdk_cairo_create(gtk_widget_get_window(widget));
1149   gdk_cairo_rectangle(cr, &event->area);
1150   cairo_clip(cr);
1151
1152   GdkColor bottom_color = GetGdkColor(ThemeProperties::COLOR_TOOLBAR);
1153   double bottom_color_rgb[] = {
1154       static_cast<double>(bottom_color.red / 257) / 255.0,
1155       static_cast<double>(bottom_color.green / 257) / 255.0,
1156       static_cast<double>(bottom_color.blue / 257) / 255.0, };
1157
1158   GtkAllocation allocation;
1159   gtk_widget_get_allocation(widget, &allocation);
1160
1161   cairo_pattern_t* pattern =
1162       cairo_pattern_create_linear(allocation.x, allocation.y,
1163                                   allocation.x,
1164                                   allocation.y + allocation.height);
1165   cairo_pattern_add_color_stop_rgb(
1166       pattern, 0.0,
1167       kTopSeparatorColor[0], kTopSeparatorColor[1], kTopSeparatorColor[2]);
1168   cairo_pattern_add_color_stop_rgb(
1169       pattern, 0.5,
1170       kMidSeparatorColor[0], kMidSeparatorColor[1], kMidSeparatorColor[2]);
1171   cairo_pattern_add_color_stop_rgb(
1172       pattern, 1.0,
1173       bottom_color_rgb[0], bottom_color_rgb[1], bottom_color_rgb[2]);
1174   cairo_set_source(cr, pattern);
1175
1176   double start_x = 0.5 + allocation.x;
1177   cairo_new_path(cr);
1178   cairo_set_line_width(cr, 1.0);
1179   cairo_move_to(cr, start_x, allocation.y);
1180   cairo_line_to(cr, start_x, allocation.y + allocation.height);
1181   cairo_stroke(cr);
1182   cairo_destroy(cr);
1183   cairo_pattern_destroy(pattern);
1184
1185   return TRUE;
1186 }
1187
1188 void GtkThemeService::OnUsesSystemThemeChanged() {
1189   use_gtk_ = profile()->GetPrefs()->GetBoolean(prefs::kUsesSystemTheme);
1190 }