Remove some unused theming code for GTK.

chrome/browser/ui/libgtk2ui/gtk2_ui.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/libgtk2ui/gtk2_ui.h"
 
 #include <math.h>
 #include <pango/pango.h>
 #include <X11/Xcursor/Xcursor.h>
 #include <set>
@@ skipping 279 matching lines @@
 
 // Prefix for app indicator ids
 const char kAppIndicatorIdPrefix[] = "chrome_app_indicator_";
 
 // Number of app indicators used (used as part of app-indicator id).
 int indicators_count;
 
 // The unknown content type.
 const char* kUnknownContentType = "application/octet-stream";
 
-// The size of the rendered toolbar image.
-const int kToolbarImageWidth = 64;
-const int kToolbarImageHeight = 128;
-
 // Values used as the new luminance and saturation values in the inactive tab
 // text color.
 const double kInactiveLuminance = 0.15;
 const double kInactiveSaturation = 0.3;
 
 // TODO(erg): ThemeService has a whole interface just for reading default
 // constants. Figure out what to do with that more long term; for now, just
 // copy the constants themselves here.
 //
 // Default tints.
 const color_utils::HSL kDefaultTintFrameIncognito = { -1, 0.2f, 0.35f };
 const color_utils::HSL kDefaultTintFrameIncognitoInactive = { -1, 0.3f, 0.6f };
-const color_utils::HSL kDefaultTintBackgroundTab = { -1, 0.5, 0.75 };
 
 #if GTK_MAJOR_VERSION == 3
 const color_utils::HSL kDefaultTintFrameInactive = { -1, -1, 0.75f };
 #endif
 
 // Picks a button tint from a set of background colors. While
 // |accent_color| will usually be the same color through a theme, this
 // function will get called with the normal GtkLabel |text_color|/GtkWindow
 // |background_color| pair and the GtkEntry |text_color|/|background_color|
 // pair. While 3/4 of the time the resulting tint will be the same, themes that
@@ skipping 164 matching lines @@
 
 Gtk2UI::Gtk2UI()
     : default_font_size_pixels_(0),
       default_font_style_(gfx::Font::NORMAL),
       default_font_weight_(gfx::Font::Weight::NORMAL),
       middle_click_action_(GetDefaultMiddleClickAction()),
       device_scale_factor_(1.0) {
   GtkInitFromCommandLine(*base::CommandLine::ForCurrentProcess());
 }
 
-
+Gtk2UI::~Gtk2UI() {}
 
 void OnThemeChanged(GObject* obj, GParamSpec* param, Gtk2UI* gtkui) {
   gtkui->ResetStyle();
 }
 
 void Gtk2UI::Initialize() {
   GtkSettings* settings = gtk_settings_get_default();
   g_signal_connect_after(settings,
                          "notify::gtk-theme-name",
                          G_CALLBACK(OnThemeChanged),
@@ skipping 22 matching lines @@
   indicators_count = 0;
 
   // Instantiate the singleton instance of Gtk2EventLoop.
   Gtk2EventLoop::GetInstance();
 }
 
 void Gtk2UI::MaterialDesignControllerReady() {
   UpdateMaterialDesignColors();
 }
 
-Gtk2UI::~Gtk2UI() {
-  ClearAllThemeData();
-}
-
-gfx::Image Gtk2UI::GetThemeImageNamed(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;
-
-  gfx::Image image = GenerateGtkThemeImage(id);
-
-  if (image.IsEmpty()) {
-    SkBitmap bitmap = GenerateGtkThemeBitmap(id);
-    if (!bitmap.empty())
-      image = gfx::Image::CreateFrom1xBitmap(bitmap);
-  }
-
-  gtk_images_[id] = image;
-  return image;
-}
-
 bool Gtk2UI::GetTint(int id, color_utils::HSL* tint) const {
   switch (id) {
     // Tints for which the cross-platform default is fine. Before adding new
     // values here, specifically verify they work well on Linux.
     case ThemeProperties::TINT_BACKGROUND_TAB:
     // TODO(estade): Return something useful for TINT_BUTTONS so that chrome://
     // page icons are colored appropriately.
     case ThemeProperties::TINT_BUTTONS:
       break;
     default:
       // Assume any tints not specifically verified on Linux aren't usable.
       // TODO(pkasting): Try to remove values from |colors_| that could just be
       // added to the group above instead.
       NOTREACHED();
   }
   return false;
 }
 
 bool Gtk2UI::GetColor(int id, SkColor* color) const {
   ColorMap::const_iterator it = colors_.find(id);
   if (it != colors_.end()) {
     *color = it->second;
     return true;
   }
 
   return false;
 }
 
-bool Gtk2UI::HasCustomImage(int id) const {
-  return !GetThemeImageNamed(id).IsEmpty();
-}
-
 SkColor Gtk2UI::GetFocusRingColor() const {
   return focus_ring_color_;
 }
 
 SkColor Gtk2UI::GetThumbActiveColor() const {
   return thumb_active_color_;
 }
 
 SkColor Gtk2UI::GetThumbInactiveColor() const {
   return thumb_inactive_color_;
@@ skipping 313 matching lines @@
 
   colors_[ThemeProperties::COLOR_TAB_TEXT] = label_color;
   colors_[ThemeProperties::COLOR_BOOKMARK_TEXT] = label_color;
 
   UpdateDefaultFont();
 
   // Build the various icon tints.
   GetNormalButtonTintHSL(&button_tint_);
   GetNormalEntryForegroundHSL(&entry_tint_);
   GetSelectedEntryForegroundHSL(&selected_entry_tint_);
-  SkColor frame_color = BuildFrameColors();
 
   // 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
+  // tinted version of the normal 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;
   color_utils::SkColorToHSL(
       theme->GetSystemColor(ui::NativeTheme::kColorId_WindowBackground),
       &inactive_tab_text_hsl);
   inactive_tab_text_hsl.s = kInactiveLuminance;
   inactive_tab_text_hsl.l = kInactiveSaturation;
 
   colors_[ThemeProperties::COLOR_BACKGROUND_TAB_TEXT] =
@@ skipping 14 matching lines @@
 
   colors_[ThemeProperties::COLOR_NTP_BACKGROUND] = ntp_background;
   colors_[ThemeProperties::COLOR_NTP_TEXT] = ntp_foreground;
 
   // The NTP header is the color that surrounds the current active thumbnail on
   // the NTP, and acts as the border of the "Recent Links" box. It would be
   // awesome if they were separated so we could use GetBorderColor() for the
   // border around the "Recent Links" section, but matching the frame color is
   // more important.
 
+  BuildFrameColors();
+  SkColor frame_color = colors_[ThemeProperties::COLOR_FRAME];
   colors_[ThemeProperties::COLOR_NTP_HEADER] = frame_color;
   colors_[ThemeProperties::COLOR_NTP_SECTION] = toolbar_color;
   colors_[ThemeProperties::COLOR_NTP_SECTION_TEXT] = label_color;
 
   SkColor link_color =
       theme->GetSystemColor(ui::NativeTheme::kColorId_LinkEnabled);
   colors_[ThemeProperties::COLOR_NTP_LINK] = link_color;
   colors_[ThemeProperties::COLOR_NTP_LINK_UNDERLINE] = link_color;
   colors_[ThemeProperties::COLOR_NTP_SECTION_LINK] = link_color;
   colors_[ThemeProperties::COLOR_NTP_SECTION_LINK_UNDERLINE] = link_color;
@@ skipping 52 matching lines @@
       !ui::MaterialDesignController::IsModeMaterial()) {
     return;
   }
   NativeThemeGtk2* theme = NativeThemeGtk2::instance();
   SkColor label_color =
       theme->GetSystemColor(ui::NativeTheme::kColorId_LabelEnabledColor);
   colors_[ThemeProperties::COLOR_BACKGROUND_TAB_TEXT] =
       color_utils::BlendTowardOppositeLuma(label_color, 50);
 }
 
-SkColor Gtk2UI::BuildFrameColors() {
+void Gtk2UI::BuildFrameColors() {
   NativeThemeGtk2* theme = NativeThemeGtk2::instance();
+  color_utils::HSL kDefaultFrameShift = { -1, -1, 0.4 };
+
   SkColor frame_color =
       theme->GetSystemColor(ui::NativeTheme::kColorId_WindowBackground);
-  SkColor temp_color;
-
-#if GTK_MAJOR_VERSION == 2
-  color_utils::HSL kDefaultFrameShift = { -1, -1, 0.4 };
-  GtkStyle* style = gtk_rc_get_style(theme->GetWindow());
-
   frame_color = color_utils::HSLShift(frame_color, kDefaultFrameShift);
   theme->GetChromeStyleColor("frame-color", &frame_color);
+  colors_[ThemeProperties::COLOR_FRAME] = frame_color;
 
-  temp_color = frame_color;
-  colors_[ThemeProperties::COLOR_FRAME] = temp_color;
-
-  temp_color = color_utils::HSLShift(
+  GtkStyle* style = gtk_rc_get_style(theme->GetWindow());
+  SkColor temp_color = color_utils::HSLShift(
       GdkColorToSkColor(style->bg[GTK_STATE_INSENSITIVE]),
       kDefaultFrameShift);
   theme->GetChromeStyleColor("inactive-frame-color", &temp_color);

[Elliot Glaysher, 2016/08/30 17:40:04]

I'm pretty sure this will at least visually break the GTK3 stuff. What's going
on with GetChromeStyleColor is that in a GTK2 ifdef, it uses a GTK2 specific API
call to look up style information in the gtk2rc file, which lets a gtk theme
author inject colors.

This probably compiles, but the frame will probably be totally busted.

In the #else/gtk3 block here, we're getting the frame image that gtk3 would
render, and are then just grabbing a color out of it. GenerateFrameImage() is
grabbing the pixels from an actual GtkHeaderBar for this.

If you just leave GenerateFrameImage(), this will all probably work.

[Evan Stade, 2016/08/31 01:15:47]

ah, that's more or less what I suspected, but I was wary of hoping it would
"just work" without having a means to test it. Updated to preserve this
functionality, fingers crossed.

   colors_[ThemeProperties::COLOR_FRAME_INACTIVE] = temp_color;
 
   temp_color = color_utils::HSLShift(
       frame_color,
       kDefaultTintFrameIncognito);
   theme->GetChromeStyleColor("incognito-frame-color", &temp_color);
   colors_[ThemeProperties::COLOR_FRAME_INCOGNITO] = temp_color;
 
   temp_color = color_utils::HSLShift(
       frame_color,
       kDefaultTintFrameIncognitoInactive);
   theme->GetChromeStyleColor("incognito-inactive-frame-color", &temp_color);
   colors_[ThemeProperties::COLOR_FRAME_INCOGNITO_INACTIVE] = temp_color;
-#else
-  const SkBitmap* bitmap;
-
-  bitmap = GetThemeImageNamed(IDR_THEME_FRAME).ToSkBitmap();
-  bitmap->lockPixels();
-  temp_color = bitmap->getColor(bitmap->width() / 2, bitmap->height() - 1);
-  bitmap->unlockPixels();
-  colors_[ThemeProperties::COLOR_FRAME] = temp_color;
-
-  bitmap = GetThemeImageNamed(IDR_THEME_FRAME_INACTIVE).ToSkBitmap();
-  bitmap->lockPixels();
-  temp_color = bitmap->getColor(bitmap->width() / 2, bitmap->height() - 1);
-  bitmap->unlockPixels();
-  colors_[ThemeProperties::COLOR_FRAME_INACTIVE] = temp_color;
-
-  bitmap = GetThemeImageNamed(IDR_THEME_FRAME_INCOGNITO).ToSkBitmap();
-  bitmap->lockPixels();
-  temp_color = bitmap->getColor(bitmap->width() / 2, bitmap->height() - 1);
-  bitmap->unlockPixels();
-  colors_[ThemeProperties::COLOR_FRAME_INCOGNITO] = temp_color;
-
-  bitmap = GetThemeImageNamed(IDR_THEME_FRAME_INCOGNITO_INACTIVE).ToSkBitmap();
-  bitmap->lockPixels();
-  temp_color = bitmap->getColor(bitmap->width() / 2, bitmap->height() - 1);
-  bitmap->unlockPixels();
-  colors_[ThemeProperties::COLOR_FRAME_INCOGNITO_INACTIVE] = temp_color;
-#endif
-
-  return frame_color;
-}
-
-gfx::Image Gtk2UI::GenerateGtkThemeImage(int id) const {
-  gfx::ImageSkiaSource* source = NULL;
-
-  switch (id) {
-    case IDR_BACK:
-      source = new GtkThemeIconSource(id, "go-previous", true);
-      break;
-    case IDR_BACK_D:
-      source = new GtkThemeIconSource(id, "go-previous", false);
-      break;
-
-    case IDR_FORWARD:
-      source = new GtkThemeIconSource(id, "go-next", true);
-      break;
-    case IDR_FORWARD_D:
-      source = new GtkThemeIconSource(id, "go-next", false);
-      break;
-
-    case IDR_HOME:
-      source = new GtkThemeIconSource(id, "go-home", true);
-      break;
-
-    case IDR_RELOAD:
-      source = new GtkThemeIconSource(id, "view-refresh", true);
-      break;
-    case IDR_RELOAD_D:
-      source = new GtkThemeIconSource(id, "view-refresh", false);
-      break;
-
-    case IDR_STOP:
-      source = new GtkThemeIconSource(id, "process-stop", true);
-      break;
-    case IDR_STOP_D:
-      source = new GtkThemeIconSource(id, "process-stop", false);
-      break;
-
-
-    // The toolbar bezels don't seem to be in use anymore, remove at your
-    // discretion
-    case IDR_TOOLBAR_BEZEL_HOVER: {
-      gfx::Size size = ResourceBundle::GetSharedInstance().
-          GetImageSkiaNamed(id)->size();
-      source = new GtkButtonImageSource("IDR_BUTTON_HOVER", size);
-      break;
-    }
-    case IDR_TOOLBAR_BEZEL_PRESSED: {
-      gfx::Size size = ResourceBundle::GetSharedInstance().
-          GetImageSkiaNamed(id)->size();
-      source = new GtkButtonImageSource("IDR_BUTTON_PRESSED", size);
-      break;
-    }
-  }
-
-  if (source)
-    return gfx::Image(gfx::ImageSkia(source, 1));
-
-  return gfx::Image();
-}
-
-SkBitmap Gtk2UI::GenerateGtkThemeBitmap(int id) const {
-  switch (id) {
-    case IDR_THEME_TOOLBAR: {
-      if (ui::MaterialDesignController::IsModeMaterial())
-        break;
-
-      SkBitmap bitmap;
-      bitmap.allocN32Pixels(kToolbarImageWidth, kToolbarImageHeight);
-      bitmap.eraseColor(
-          NativeThemeGtk2::instance()->GetSystemColor(
-              ui::NativeTheme::kColorId_LabelBackgroundColor));
-      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_FRAME:
-    case IDR_THEME_FRAME:
-      return GenerateFrameImage(ThemeProperties::COLOR_FRAME,
-                                "frame-gradient-color");
-    case IDR_FRAME_INACTIVE:
-    case IDR_THEME_FRAME_INACTIVE:
-      return GenerateFrameImage(ThemeProperties::COLOR_FRAME_INACTIVE,
-                                "inactive-frame-gradient-color");
-    case IDR_THEME_FRAME_INCOGNITO:
-      return GenerateFrameImage(ThemeProperties::COLOR_FRAME_INCOGNITO,
-                                "incognito-frame-gradient-color");
-    case IDR_THEME_FRAME_INCOGNITO_INACTIVE: {
-      return GenerateFrameImage(
-          ThemeProperties::COLOR_FRAME_INCOGNITO_INACTIVE,
-          "incognito-inactive-frame-gradient-color");
-    }
-    // Icons that sit inside the omnibox shouldn't receive TINT_BUTTONS and
-    // instead should tint based on the foreground text entry color in GTK+
-    // mode because some themes that try to be dark *and* light have very
-    // different colors between the omnibox and the normal background area.
-    // TODO(erg): Decide what to do about other icons that appear in the
-    // omnibox, e.g. content settings icons.
-    case IDR_OMNIBOX_CALCULATOR:
-    case IDR_OMNIBOX_EXTENSION_APP:
-    case IDR_OMNIBOX_HTTP:
-    case IDR_OMNIBOX_SEARCH:
-    case IDR_OMNIBOX_STAR:
-    case IDR_OMNIBOX_TTS: {
-      return GenerateTintedIcon(id, entry_tint_);
-    }
-
-    // TODO(erg): The dropdown arrow should be tinted because we're injecting
-    // various background GTK colors, but the code that accesses them needs to
-    // be modified so that they ask their ui::ThemeProvider instead of the
-    // ResourceBundle. (i.e. in a light on dark theme, the dropdown arrow will
-    // be dark on dark)
-    case IDR_MENU_DROPARROW:
-      return GenerateTintedIcon(id, button_tint_);
-  }
-
-  return SkBitmap();
-}
-
-SkBitmap Gtk2UI::GenerateFrameImage(
-    int color_id,
-    const char* gradient_name) const {
-#if GTK_MAJOR_VERSION == 2
-  if (ui::MaterialDesignController::IsModeMaterial())
-    return SkBitmap();
-
-  ColorMap::const_iterator it = colors_.find(color_id);
-  DCHECK(it != colors_.end());
-  SkColor base = it->second;
-
-  // 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).
-  const color_utils::HSL kGtkFrameShift = { -1, -1, 0.58 };
-  gfx::Canvas canvas(gfx::Size(kToolbarImageWidth, kToolbarImageHeight),
-      1.0f, true);
-
-  SkColor gradient_top_color = color_utils::HSLShift(base, kGtkFrameShift);
-  int gradient_size;
-
-  NativeThemeGtk2::instance()->GetChromeStyleColor(gradient_name,
-                                                   &gradient_top_color);
-  gtk_widget_style_get(NativeThemeGtk2::instance()->GetWindow(),
-                       "frame-gradient-size", &gradient_size,
-                       NULL);
-
-  if (gradient_size) {
-    SkPaint paint;
-    paint.setStyle(SkPaint::kFill_Style);
-    paint.setAntiAlias(true);
-    paint.setShader(gfx::CreateGradientShader(
-        0, gradient_size, gradient_top_color, base));
-
-    canvas.DrawRect(gfx::Rect(0, 0, kToolbarImageWidth, gradient_size), paint);
-  }
-
-  canvas.FillRect(gfx::Rect(0, gradient_size, kToolbarImageWidth,
-                            kToolbarImageHeight - gradient_size), base);
-  return canvas.ExtractImageRep().sk_bitmap();
-#else
-  // Render a GtkHeaderBar as our title bar, cropping out any curved edges on
-  // the left and right sides. Also remove the bottom border for good measure.
-  SkBitmap bitmap;
-  bitmap.allocN32Pixels(kToolbarImageWidth, 40);
-  bitmap.eraseColor(0);
-
-  static GtkWidget* title = NULL;
-  if (!title) {
-    title = gtk_header_bar_new();
-    gtk_widget_set_size_request(title, kToolbarImageWidth * 2, 48);
-
-    GtkWidget* window = gtk_offscreen_window_new();
-    gtk_container_add(GTK_CONTAINER(window), title);
-
-    gtk_widget_show_all(window);
-  }
-
-  cairo_surface_t* surface = cairo_image_surface_create_for_data(
-    static_cast<unsigned char*>(bitmap.getAddr(0, 0)),
-    CAIRO_FORMAT_ARGB32,
-    bitmap.width(), bitmap.height(),
-    bitmap.width() * 4);
-  cairo_t* cr = cairo_create(surface);
-  cairo_translate(cr, kToolbarImageWidth / -2, 0);
-  gtk_widget_draw(title, cr);
-  cairo_destroy(cr);
-  cairo_surface_destroy(surface);
-
-  switch (color_id) {
-    case ThemeProperties::COLOR_FRAME_INACTIVE:
-      return SkBitmapOperations::CreateHSLShiftedBitmap(bitmap,
-          kDefaultTintFrameInactive);
-    case ThemeProperties::COLOR_FRAME_INCOGNITO:
-      return SkBitmapOperations::CreateHSLShiftedBitmap(bitmap,
-          kDefaultTintFrameIncognito);
-    case ThemeProperties::COLOR_FRAME_INCOGNITO_INACTIVE:
-      return SkBitmapOperations::CreateHSLShiftedBitmap(bitmap,
-          kDefaultTintFrameIncognitoInactive);
-  }
-
-  return bitmap;
-#endif
-}
-
-SkBitmap Gtk2UI::GenerateTabImage(int base_id) const {
-  if (ui::MaterialDesignController::IsModeMaterial())
-    return SkBitmap();
-
-  const SkBitmap* base_image = GetThemeImageNamed(base_id).ToSkBitmap();
-  SkBitmap bg_tint = SkBitmapOperations::CreateHSLShiftedBitmap(
-      *base_image, kDefaultTintBackgroundTab);
-  return SkBitmapOperations::CreateTiledBitmap(
-      bg_tint, 0, 0, bg_tint.width(), bg_tint.height());
-}
-
-SkBitmap Gtk2UI::GenerateTintedIcon(
-    int base_id,
-    const color_utils::HSL& tint) const {
-  ui::ResourceBundle& rb = ui::ResourceBundle::GetSharedInstance();
-  return SkBitmapOperations::CreateHSLShiftedBitmap(
-      rb.GetImageNamed(base_id).AsBitmap(), tint);
 }
 
 void Gtk2UI::GetNormalButtonTintHSL(color_utils::HSL* tint) const {
   NativeThemeGtk2* theme = NativeThemeGtk2::instance();
 
   SkColor accent_color =
       theme->GetSystemColor(
           ui::NativeTheme::kColorId_ButtonHighlightColor);
   SkColor text_color =
       theme->GetSystemColor(
@@ skipping 25 matching lines @@
   // 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].
   SkColor color =
       NativeThemeGtk2::instance()->GetSystemColor(
           ui::NativeTheme::kColorId_TextfieldSelectionColor);
 
   color_utils::SkColorToHSL(color, tint);
 }
 
-void Gtk2UI::ClearAllThemeData() {
-  gtk_images_.clear();
-}
-
 void Gtk2UI::UpdateDefaultFont() {
   PangoContext* pc = gtk_widget_get_pango_context(
     NativeThemeGtk2::instance()->GetLabel());
   const PangoFontDescription* desc = pango_context_get_font_description(pc);
 
   // Use gfx::FontRenderParams to select a family and determine the rendering
   // settings.
   gfx::FontRenderParamsQuery query;
   query.families = base::SplitString(pango_font_description_get_family(desc),
                                      ",", base::TRIM_WHITESPACE,
@@ skipping 21 matching lines @@
   // TODO(davemoore): What about PANGO_STYLE_OBLIQUE?
   if (pango_font_description_get_style(desc) == PANGO_STYLE_ITALIC)
     query.style |= gfx::Font::ITALIC;
 
   default_font_render_params_ =
       gfx::GetFontRenderParams(query, &default_font_family_);
   default_font_style_ = query.style;
 }
 
 void Gtk2UI::ResetStyle() {
-  ClearAllThemeData();
   LoadGtkValues();
   // TODO(varkha): There will be no need to call UpdateMaterialDesignColors()
   // once Material Design is on unconditionally.
   UpdateMaterialDesignColors();
   NativeThemeGtk2::instance()->NotifyObservers();
 }
 
 void Gtk2UI::UpdateDeviceScaleFactor(float device_scale_factor) {
   device_scale_factor_ = device_scale_factor;
   UpdateDefaultFont();
 }
 
 float Gtk2UI::GetDeviceScaleFactor() const {
   if (display::Display::HasForceDeviceScaleFactor())
     return display::Display::GetForcedDeviceScaleFactor();
   const int kCSSDefaultDPI = 96;
   const float scale = GetDPI() / kCSSDefaultDPI;
 
   // Blacklist scaling factors <130% (crbug.com/484400) and round
   // to 1 decimal to prevent rendering problems (crbug.com/485183).
   return scale < 1.3f ? 1.0f : roundf(scale * 10) / 10;
 }
 
 }  // namespace libgtk2ui
 
 views::LinuxUI* BuildGtk2UI() {
   return new libgtk2ui::Gtk2UI;
 }