LibGtkUi: Partition NativeThemeGtk into NativeThemeGtk2 and NativeThemeGtk3

chrome/browser/ui/libgtkui/gtk_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/libgtkui/gtk_ui.h"
 
 #include <math.h>
 #include <pango/pango.h>
 #include <X11/Xcursor/Xcursor.h>
 
 #include <cmath>
 #include <set>
 #include <utility>
 
 #include "base/command_line.h"
 #include "base/debug/leak_annotations.h"
 #include "base/environment.h"
 #include "base/i18n/rtl.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/nix/mime_util_xdg.h"
 #include "base/nix/xdg_util.h"
 #include "base/stl_util.h"
 #include "base/strings/string_split.h"
 #include "base/strings/stringprintf.h"
 #include "chrome/browser/themes/theme_properties.h"
 #include "chrome/browser/ui/libgtkui/app_indicator_icon.h"
+#include "chrome/browser/ui/libgtkui/chrome_gtk_frame.h"
 #include "chrome/browser/ui/libgtkui/gtk_event_loop.h"
 #include "chrome/browser/ui/libgtkui/gtk_key_bindings_handler.h"
 #include "chrome/browser/ui/libgtkui/gtk_status_icon.h"
 #include "chrome/browser/ui/libgtkui/gtk_util.h"
-#include "chrome/browser/ui/libgtkui/native_theme_gtk.h"
 #include "chrome/browser/ui/libgtkui/print_dialog_gtk.h"
 #include "chrome/browser/ui/libgtkui/printing_gtk_util.h"
 #include "chrome/browser/ui/libgtkui/select_file_dialog_impl.h"
 #include "chrome/browser/ui/libgtkui/skia_utils_gtk.h"
 #include "chrome/browser/ui/libgtkui/unity_service.h"
 #include "chrome/browser/ui/libgtkui/x11_input_method_context_impl_gtk.h"
 #include "chrome/grit/theme_resources.h"
 #include "components/grit/components_scaled_resources.h"
 #include "printing/features/features.h"
 #include "third_party/skia/include/core/SkBitmap.h"
@@ skipping 11 matching lines @@
 #include "ui/gfx/skia_util.h"
 #include "ui/gfx/x/x11_types.h"
 #include "ui/native_theme/native_theme.h"
 #include "ui/resources/grit/ui_resources.h"
 #include "ui/views/controls/button/blue_button.h"
 #include "ui/views/controls/button/label_button.h"
 #include "ui/views/controls/button/label_button_border.h"
 #include "ui/views/linux_ui/window_button_order_observer.h"
 #include "ui/views/resources/grit/views_resources.h"
 
+#if GTK_MAJOR_VERSION == 2
+#include "chrome/browser/ui/libgtkui/native_theme_gtk2.h"  // nogncheck
+#elif GTK_MAJOR_VERSION == 3
+#include "chrome/browser/ui/libgtkui/native_theme_gtk3.h"  // nogncheck
+#endif
+
 #if BUILDFLAG(ENABLE_BASIC_PRINTING)
 #include "printing/printing_context_linux.h"
 #endif
 #if defined(USE_GCONF)
 #include "chrome/browser/ui/libgtkui/gconf_listener.h"
 #endif
 
 // A minimized port of GtkThemeService into something that can provide colors
 // and images for aura.
 //
@@ skipping 230 matching lines @@
 }
 
 // Returns a gfx::FontRenderParams corresponding to GTK's configuration.
 gfx::FontRenderParams GetGtkFontRenderParams() {
   GtkSettings* gtk_settings = gtk_settings_get_default();
   CHECK(gtk_settings);
   gint antialias = 0;
   gint hinting = 0;
   gchar* hint_style = NULL;
   gchar* rgba = NULL;
-  g_object_get(gtk_settings,
-               "gtk-xft-antialias", &antialias,
-               "gtk-xft-hinting", &hinting,
-               "gtk-xft-hintstyle", &hint_style,
-               "gtk-xft-rgba", &rgba,
-               NULL);
+  g_object_get(gtk_settings, "gtk-xft-antialias", &antialias, "gtk-xft-hinting",
+               &hinting, "gtk-xft-hintstyle", &hint_style, "gtk-xft-rgba",
+               &rgba, NULL);
 
   gfx::FontRenderParams params;
   params.antialiasing = antialias != 0;
 
   if (hinting == 0 || !hint_style || strcmp(hint_style, "hintnone") == 0) {
     params.hinting = gfx::FontRenderParams::HINTING_NONE;
   } else if (strcmp(hint_style, "hintslight") == 0) {
     params.hinting = gfx::FontRenderParams::HINTING_SLIGHT;
   } else if (strcmp(hint_style, "hintmedium") == 0) {
     params.hinting = gfx::FontRenderParams::HINTING_MEDIUM;
@@ skipping 75 matching lines @@
       return views::LinuxUI::MIDDLE_CLICK_ACTION_NONE;
     default:
       return views::LinuxUI::MIDDLE_CLICK_ACTION_LOWER;
   }
 }
 
 }  // namespace
 
 Gtk2UI::Gtk2UI() : middle_click_action_(GetDefaultMiddleClickAction()) {
   GtkInitFromCommandLine(*base::CommandLine::ForCurrentProcess());
+#if GTK_MAJOR_VERSION == 2
+  native_theme_ = NativeThemeGtk2::instance();
+  fake_window_ = chrome_gtk_frame_new();
+  gtk_widget_realize(fake_window_);  // Is this necessary?
+#elif GTK_MAJOR_VERSION == 3
+  native_theme_ = NativeThemeGtk3::instance();
+#else
+#error "Unsupported GTK version"
+#endif
 }
 
-Gtk2UI::~Gtk2UI() {}
+Gtk2UI::~Gtk2UI() {
+#if GTK_MAJOR_VERSION == 2
+  gtk_widget_destroy(fake_window_);
+#endif
+}
 
 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), this);
   g_signal_connect_after(settings, "notify::gtk-icon-theme-name",
@@ skipping 87 matching lines @@
   static const gint kGtkDefaultCursorBlinkTime = 1200;
 
   // Dividing GTK's cursor blink cycle time (in milliseconds) by this value
   // yields an appropriate value for
   // content::RendererPreferences::caret_blink_interval.  This matches the
   // logic in the WebKit GTK port.
   static const double kGtkCursorBlinkCycleFactor = 2000.0;
 
   gint cursor_blink_time = kGtkDefaultCursorBlinkTime;
   gboolean cursor_blink = TRUE;
-  g_object_get(gtk_settings_get_default(),
-               "gtk-cursor-blink-time", &cursor_blink_time,
-               "gtk-cursor-blink", &cursor_blink,
-               NULL);
+  g_object_get(gtk_settings_get_default(), "gtk-cursor-blink-time",
+               &cursor_blink_time, "gtk-cursor-blink", &cursor_blink, NULL);
   return cursor_blink ? (cursor_blink_time / kGtkCursorBlinkCycleFactor) : 0.0;
 }
 
 ui::NativeTheme* Gtk2UI::GetNativeTheme(aura::Window* window) const {
   ui::NativeTheme* native_theme_override = NULL;
   if (!native_theme_overrider_.is_null())
     native_theme_override = native_theme_overrider_.Run(window);
 
   if (native_theme_override)
     return native_theme_override;
 
-  return NativeThemeGtk2::instance();
+  return native_theme_;
 }
 
 void Gtk2UI::SetNativeThemeOverride(const NativeThemeGetter& callback) {
   native_theme_overrider_ = callback;
 }
 
 bool Gtk2UI::GetDefaultUsesSystemTheme() const {
   std::unique_ptr<base::Environment> env(base::Environment::Create());
 
   switch (base::nix::GetDesktopEnvironment(env.get())) {
@@ skipping 64 matching lines @@
     gfx::ImageSkia image_skia = gfx::ImageSkia::CreateFrom1xBitmap(bitmap);
     image_skia.MakeThreadSafe();
     return gfx::Image(image_skia);
   }
   return gfx::Image();
 }
 
 std::unique_ptr<views::Border> Gtk2UI::CreateNativeBorder(
     views::LabelButton* owning_button,
     std::unique_ptr<views::LabelButtonBorder> border) {
-  if (owning_button->GetNativeTheme() != NativeThemeGtk2::instance())
+  if (owning_button->GetNativeTheme() != native_theme_)
     return std::move(border);
 
   std::unique_ptr<views::LabelButtonAssetBorder> gtk_border(
       new views::LabelButtonAssetBorder(owning_button->style()));
 
   gtk_border->set_insets(border->GetInsets());
 
   static struct {
     const char* idr;
     const char* idr_blue;
@@ skipping 133 matching lines @@
     key_bindings_handler_.reset(new Gtk2KeyBindingsHandler);
 
   return key_bindings_handler_->MatchEvent(event, commands);
 }
 
 void Gtk2UI::SetScrollbarColors() {
   thumb_active_color_ = SkColorSetRGB(244, 244, 244);
   thumb_inactive_color_ = SkColorSetRGB(234, 234, 234);
   track_color_ = SkColorSetRGB(211, 211, 211);
 
-  NativeThemeGtk2::instance()->GetChromeStyleColor(
-      "scrollbar-slider-prelight-color", &thumb_active_color_);
-  NativeThemeGtk2::instance()->GetChromeStyleColor(
-      "scrollbar-slider-normal-color", &thumb_inactive_color_);
-  NativeThemeGtk2::instance()->GetChromeStyleColor("scrollbar-trough-color",
-                                                   &track_color_);
+  GetChromeStyleColor("scrollbar-slider-prelight-color", &thumb_active_color_);
+  GetChromeStyleColor("scrollbar-slider-normal-color", &thumb_inactive_color_);
+  GetChromeStyleColor("scrollbar-trough-color", &track_color_);
 }
 
 void Gtk2UI::LoadGtkValues() {
   // TODO(erg): GtkThemeService had a comment here about having to muck with
   // the raw Prefs object to remove prefs::kCurrentThemeImages or else we'd
   // regress startup time. Figure out how to do that when we can't access the
   // prefs system from here.
 
-  NativeThemeGtk2* theme = NativeThemeGtk2::instance();
-
   SkColor toolbar_color =
-      theme->GetSystemColor(ui::NativeTheme::kColorId_DialogBackground);
-  SkColor label_color =
-      theme->GetSystemColor(ui::NativeTheme::kColorId_LabelEnabledColor);
+      native_theme_->GetSystemColor(ui::NativeTheme::kColorId_DialogBackground);
+  SkColor label_color = native_theme_->GetSystemColor(
+      ui::NativeTheme::kColorId_LabelEnabledColor);
 
   colors_[ThemeProperties::COLOR_CONTROL_BACKGROUND] = toolbar_color;
   colors_[ThemeProperties::COLOR_TOOLBAR] = toolbar_color;
 
   colors_[ThemeProperties::COLOR_TOOLBAR_BUTTON_ICON] =
       color_utils::DeriveDefaultIconColor(label_color);
 
   colors_[ThemeProperties::COLOR_TAB_TEXT] = label_color;
   colors_[ThemeProperties::COLOR_BOOKMARK_TEXT] = label_color;
   colors_[ThemeProperties::COLOR_BACKGROUND_TAB_TEXT] =
       color_utils::BlendTowardOppositeLuma(label_color, 50);
 
   UpdateDeviceScaleFactor();
 
   // Build the various icon tints.
   GetNormalButtonTintHSL(&button_tint_);
   GetNormalEntryForegroundHSL(&entry_tint_);
   GetSelectedEntryForegroundHSL(&selected_entry_tint_);
 
   // We pick the text and background colors for the NTP out of the colors for a
   // GtkEntry. We do this because GtkEntries background color is never the same
   // as |toolbar_color|, is usually a white, and when it isn't a white,
   // provides sufficient contrast to |toolbar_color|. Try this out with
   // Darklooks, HighContrastInverse or ThinIce.
 
-  SkColor ntp_background = theme->GetSystemColor(
+  SkColor ntp_background = native_theme_->GetSystemColor(
       ui::NativeTheme::kColorId_TextfieldDefaultBackground);
-  SkColor ntp_foreground =
-      theme->GetSystemColor(ui::NativeTheme::kColorId_TextfieldDefaultColor);
+  SkColor ntp_foreground = native_theme_->GetSystemColor(
+      ui::NativeTheme::kColorId_TextfieldDefaultColor);
 
   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);
+      native_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;
 
   // Generate the colors that we pass to WebKit.
   focus_ring_color_ = frame_color;
 
   SetScrollbarColors();
 
   // 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_ = theme->GetSystemColor(
+  active_selection_bg_color_ = native_theme_->GetSystemColor(
       ui::NativeTheme::kColorId_TextfieldSelectionBackgroundFocused);
-  active_selection_fg_color_ =
-      theme->GetSystemColor(ui::NativeTheme::kColorId_TextfieldSelectionColor);
-  inactive_selection_bg_color_ = theme->GetSystemColor(
+  active_selection_fg_color_ = native_theme_->GetSystemColor(
+      ui::NativeTheme::kColorId_TextfieldSelectionColor);
+  inactive_selection_bg_color_ = native_theme_->GetSystemColor(
       ui::NativeTheme::kColorId_TextfieldReadOnlyBackground);
-  inactive_selection_fg_color_ =
-      theme->GetSystemColor(ui::NativeTheme::kColorId_TextfieldReadOnlyColor);
+  inactive_selection_fg_color_ = native_theme_->GetSystemColor(
+      ui::NativeTheme::kColorId_TextfieldReadOnlyColor);
 
   colors_[ThemeProperties::COLOR_TAB_THROBBER_SPINNING] =
-      theme->GetSystemColor(ui::NativeTheme::kColorId_ThrobberSpinningColor);
+      native_theme_->GetSystemColor(
+          ui::NativeTheme::kColorId_ThrobberSpinningColor);
   colors_[ThemeProperties::COLOR_TAB_THROBBER_WAITING] =
-      theme->GetSystemColor(ui::NativeTheme::kColorId_ThrobberWaitingColor);
+      native_theme_->GetSystemColor(
+          ui::NativeTheme::kColorId_ThrobberWaitingColor);
 }
 
 void Gtk2UI::LoadCursorTheme() {
   GtkSettings* settings = gtk_settings_get_default();
 
   gchar* theme = nullptr;
   gint size = 0;
-  g_object_get(settings,
-               "gtk-cursor-theme-name", &theme,
-               "gtk-cursor-theme-size", &size,
-               nullptr);
+  g_object_get(settings, "gtk-cursor-theme-name", &theme,
+               "gtk-cursor-theme-size", &size, nullptr);
 
   if (theme)
     XcursorSetTheme(gfx::GetXDisplay(), theme);
   if (size)
     XcursorSetDefaultSize(gfx::GetXDisplay(), size);
 
   g_free(theme);
 }
 
 void Gtk2UI::BuildFrameColors() {
 #if GTK_MAJOR_VERSION == 2
-  NativeThemeGtk2* theme = NativeThemeGtk2::instance();
   color_utils::HSL kDefaultFrameShift = {-1, -1, 0.4};
   SkColor frame_color =
-      theme->GetSystemColor(ui::NativeTheme::kColorId_WindowBackground);
+      native_theme_->GetSystemColor(ui::NativeTheme::kColorId_WindowBackground);
   frame_color = color_utils::HSLShift(frame_color, kDefaultFrameShift);
-  theme->GetChromeStyleColor("frame-color", &frame_color);
+  GetChromeStyleColor("frame-color", &frame_color);
   colors_[ThemeProperties::COLOR_FRAME] = frame_color;
 
-  GtkStyle* style = gtk_rc_get_style(theme->GetWindow());
+  GtkStyle* style = gtk_rc_get_style(fake_window_);
   SkColor temp_color = color_utils::HSLShift(
       GdkColorToSkColor(style->bg[GTK_STATE_INSENSITIVE]), kDefaultFrameShift);
-  theme->GetChromeStyleColor("inactive-frame-color", &temp_color);
+  GetChromeStyleColor("inactive-frame-color", &temp_color);
   colors_[ThemeProperties::COLOR_FRAME_INACTIVE] = temp_color;
 
   temp_color = color_utils::HSLShift(frame_color, kDefaultTintFrameIncognito);
-  theme->GetChromeStyleColor("incognito-frame-color", &temp_color);
+  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);
+  GetChromeStyleColor("incognito-inactive-frame-color", &temp_color);
   colors_[ThemeProperties::COLOR_FRAME_INCOGNITO_INACTIVE] = temp_color;
 #else
   auto set_frame_color = [this](int color_id) {
     // 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(1, 1);
     bitmap.eraseColor(0);
 
@@ skipping 38 matching lines @@
   };
 
   set_frame_color(ThemeProperties::COLOR_FRAME);
   set_frame_color(ThemeProperties::COLOR_FRAME_INACTIVE);
   set_frame_color(ThemeProperties::COLOR_FRAME_INCOGNITO);
   set_frame_color(ThemeProperties::COLOR_FRAME_INCOGNITO_INACTIVE);
 #endif
 }
 
 void Gtk2UI::GetNormalButtonTintHSL(color_utils::HSL* tint) const {
-  NativeThemeGtk2* theme = NativeThemeGtk2::instance();
-
-  SkColor accent_color =
-      theme->GetSystemColor(ui::NativeTheme::kColorId_ProminentButtonColor);
-  SkColor text_color =
-      theme->GetSystemColor(ui::NativeTheme::kColorId_LabelEnabledColor);
+  SkColor accent_color = native_theme_->GetSystemColor(
+      ui::NativeTheme::kColorId_ProminentButtonColor);
+  SkColor text_color = native_theme_->GetSystemColor(
+      ui::NativeTheme::kColorId_LabelEnabledColor);
   SkColor base_color =
-      theme->GetSystemColor(ui::NativeTheme::kColorId_DialogBackground);
+      native_theme_->GetSystemColor(ui::NativeTheme::kColorId_DialogBackground);
 
   PickButtonTintFromColors(accent_color, text_color, base_color, tint);
 }
 
 void Gtk2UI::GetNormalEntryForegroundHSL(color_utils::HSL* tint) const {
-  NativeThemeGtk2* theme = NativeThemeGtk2::instance();
-
-  SkColor accent_color =
-      theme->GetSystemColor(ui::NativeTheme::kColorId_ProminentButtonColor);
-  SkColor text_color =
-      theme->GetSystemColor(ui::NativeTheme::kColorId_TextfieldDefaultColor);
-  SkColor base_color = theme->GetSystemColor(
+  SkColor accent_color = native_theme_->GetSystemColor(
+      ui::NativeTheme::kColorId_ProminentButtonColor);
+  SkColor text_color = native_theme_->GetSystemColor(
+      ui::NativeTheme::kColorId_TextfieldDefaultColor);
+  SkColor base_color = native_theme_->GetSystemColor(
       ui::NativeTheme::kColorId_TextfieldDefaultBackground);
 
   PickButtonTintFromColors(accent_color, text_color, base_color, tint);
 }
 
 void Gtk2UI::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].
-  SkColor color = NativeThemeGtk2::instance()->GetSystemColor(
+  SkColor color = native_theme_->GetSystemColor(
       ui::NativeTheme::kColorId_TextfieldSelectionColor);
 
   color_utils::SkColorToHSL(color, tint);
 }
 
 void Gtk2UI::UpdateDefaultFont() {
-  PangoContext* pc =
-      gtk_widget_get_pango_context(NativeThemeGtk2::instance()->GetLabel());
+  GtkWidget* fake_label = gtk_label_new(nullptr);
+  g_object_ref_sink(fake_label);  // Remove the floating reference.
+  PangoContext* pc = gtk_widget_get_pango_context(fake_label);
   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, base::SPLIT_WANT_ALL);
 
   if (pango_font_description_get_size_is_absolute(desc)) {
     // If the size is absolute, it's specified in Pango units. There are
     // PANGO_SCALE Pango units in a device unit (pixel).
     const int size_pixels = pango_font_description_get_size(desc) / PANGO_SCALE;
     default_font_size_pixels_ = size_pixels;
     query.pixel_size = size_pixels;
   } else {
     // Non-absolute sizes are in points (again scaled by PANGO_SIZE).
     // Round the value when converting to pixels to match GTK's logic.
     const double size_points = pango_font_description_get_size(desc) /
                                static_cast<double>(PANGO_SCALE);
     default_font_size_pixels_ = static_cast<int>(
         GetFontSizePixelsInPoint(GetDeviceScaleFactor()) * size_points);
-   query.point_size = static_cast<int>(size_points);
+    query.point_size = static_cast<int>(size_points);
   }
 
   query.style = gfx::Font::NORMAL;
   query.weight =
       static_cast<gfx::Font::Weight>(pango_font_description_get_weight(desc));
   // 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;
+
+  gtk_widget_destroy(fake_label);
+  g_object_unref(fake_label);
+}
+
+bool Gtk2UI::GetChromeStyleColor(const char* style_property,
+                                 SkColor* ret_color) const {
+#if GTK_MAJOR_VERSION == 2
+  GdkColor* style_color = nullptr;
+  gtk_widget_style_get(fake_window_, style_property, &style_color, nullptr);
+  if (style_color) {
+    *ret_color = GdkColorToSkColor(*style_color);
+    gdk_color_free(style_color);
+    return true;
+  }
+#endif
+
+  return false;
 }
 
 void Gtk2UI::ResetStyle() {
   LoadGtkValues();
-  NativeThemeGtk2::instance()->NotifyObservers();
+  native_theme_->NotifyObservers();
 }
 
 void Gtk2UI::UpdateDeviceScaleFactor() {
   // Note: Linux chrome currently does not support dynamic DPI
   // changes.  This is to allow flags to override the DPI settings
   // during startup.
   float scale = GetRawDeviceScaleFactor();
   // Blacklist scaling factors <120% (crbug.com/484400) and round
   // to 1 decimal to prevent rendering problems (crbug.com/485183).
   device_scale_factor_ = scale < 1.2f ? 1.0f : roundf(scale * 10) / 10;
   UpdateDefaultFont();
 }
 
 float Gtk2UI::GetDeviceScaleFactor() const {
   return device_scale_factor_;
 }
 
 }  // namespace libgtkui
 
 views::LinuxUI* BuildGtk2UI() {
   return new libgtkui::Gtk2UI;
 }