Gtk3: Rename Gtk2UI and Get[FB]GColor

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>
 
@@ skipping 393 matching lines @@
       // Chrome, but at least avoid lowering windows in response to middle
       // clicks to avoid surprising users who expect the KDE behavior.
       return views::LinuxUI::MIDDLE_CLICK_ACTION_NONE;
     default:
       return views::LinuxUI::MIDDLE_CLICK_ACTION_LOWER;
   }
 }
 
 }  // namespace
 
-Gtk2UI::Gtk2UI() : middle_click_action_(GetDefaultMiddleClickAction()) {
+GtkUi::GtkUi() : 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() {
+GtkUi::~GtkUi() {
 #if GTK_MAJOR_VERSION == 2
   gtk_widget_destroy(fake_window_);
 #endif
 }
 
-void OnThemeChanged(GObject* obj, GParamSpec* param, Gtk2UI* gtkui) {
+void OnThemeChanged(GObject* obj, GParamSpec* param, GtkUi* gtkui) {
   gtkui->ResetStyle();
 }
 
-void Gtk2UI::Initialize() {
+void GtkUi::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",
                          G_CALLBACK(OnThemeChanged), this);
 
   LoadGtkValues();
 
   LoadCursorTheme();
 
 #if BUILDFLAG(ENABLE_BASIC_PRINTING)
   printing::PrintingContextLinux::SetCreatePrintDialogFunction(
       &PrintDialogGtk2::CreatePrintDialog);
   printing::PrintingContextLinux::SetPdfPaperSizeFunction(
       &GetPdfPaperSizeDeviceUnitsGtk);
 #endif
 
 #if defined(USE_GCONF)
   // We must build this after GTK gets initialized.
   gconf_listener_.reset(new GConfListener(this));
 #endif  // defined(USE_GCONF)
 
   indicators_count = 0;
 
   // Instantiate the singleton instance of Gtk2EventLoop.
   Gtk2EventLoop::GetInstance();
 }
 
-bool Gtk2UI::GetTint(int id, color_utils::HSL* tint) const {
+bool GtkUi::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 {
+bool GtkUi::GetColor(int id, SkColor* color) const {
   ColorMap::const_iterator it = colors_.find(id);
   if (it != colors_.end()) {
     *color = it->second;
     return true;
   }
 
   return false;
 }
 
-SkColor Gtk2UI::GetFocusRingColor() const {
+SkColor GtkUi::GetFocusRingColor() const {
   return focus_ring_color_;
 }
 
-SkColor Gtk2UI::GetThumbActiveColor() const {
+SkColor GtkUi::GetThumbActiveColor() const {
   return thumb_active_color_;
 }
 
-SkColor Gtk2UI::GetThumbInactiveColor() const {
+SkColor GtkUi::GetThumbInactiveColor() const {
   return thumb_inactive_color_;
 }
 
-SkColor Gtk2UI::GetTrackColor() const {
+SkColor GtkUi::GetTrackColor() const {
   return track_color_;
 }
 
-SkColor Gtk2UI::GetActiveSelectionBgColor() const {
+SkColor GtkUi::GetActiveSelectionBgColor() const {
   return active_selection_bg_color_;
 }
 
-SkColor Gtk2UI::GetActiveSelectionFgColor() const {
+SkColor GtkUi::GetActiveSelectionFgColor() const {
   return active_selection_fg_color_;
 }
 
-SkColor Gtk2UI::GetInactiveSelectionBgColor() const {
+SkColor GtkUi::GetInactiveSelectionBgColor() const {
   return inactive_selection_bg_color_;
 }
 
-SkColor Gtk2UI::GetInactiveSelectionFgColor() const {
+SkColor GtkUi::GetInactiveSelectionFgColor() const {
   return inactive_selection_fg_color_;
 }
 
-double Gtk2UI::GetCursorBlinkInterval() const {
+double GtkUi::GetCursorBlinkInterval() const {
   // From http://library.gnome.org/devel/gtk/unstable/GtkSettings.html, this is
   // the default value for gtk-cursor-blink-time.
   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);
   return cursor_blink ? (cursor_blink_time / kGtkCursorBlinkCycleFactor) : 0.0;
 }
 
-ui::NativeTheme* Gtk2UI::GetNativeTheme(aura::Window* window) const {
+ui::NativeTheme* GtkUi::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 native_theme_;
 }
 
-void Gtk2UI::SetNativeThemeOverride(const NativeThemeGetter& callback) {
+void GtkUi::SetNativeThemeOverride(const NativeThemeGetter& callback) {
   native_theme_overrider_ = callback;
 }
 
-bool Gtk2UI::GetDefaultUsesSystemTheme() const {
+bool GtkUi::GetDefaultUsesSystemTheme() const {
   std::unique_ptr<base::Environment> env(base::Environment::Create());
 
   switch (base::nix::GetDesktopEnvironment(env.get())) {
     case base::nix::DESKTOP_ENVIRONMENT_GNOME:
     case base::nix::DESKTOP_ENVIRONMENT_UNITY:
     case base::nix::DESKTOP_ENVIRONMENT_XFCE:
       return true;
     case base::nix::DESKTOP_ENVIRONMENT_KDE3:
     case base::nix::DESKTOP_ENVIRONMENT_KDE4:
     case base::nix::DESKTOP_ENVIRONMENT_KDE5:
     case base::nix::DESKTOP_ENVIRONMENT_OTHER:
       return false;
   }
   // Unless GetDesktopEnvironment() badly misbehaves, this should never happen.
   NOTREACHED();
   return false;
 }
 
-void Gtk2UI::SetDownloadCount(int count) const {
+void GtkUi::SetDownloadCount(int count) const {
   if (unity::IsRunning())
     unity::SetDownloadCount(count);
 }
 
-void Gtk2UI::SetProgressFraction(float percentage) const {
+void GtkUi::SetProgressFraction(float percentage) const {
   if (unity::IsRunning())
     unity::SetProgressFraction(percentage);
 }
 
-bool Gtk2UI::IsStatusIconSupported() const {
+bool GtkUi::IsStatusIconSupported() const {
   return true;
 }
 
-std::unique_ptr<views::StatusIconLinux> Gtk2UI::CreateLinuxStatusIcon(
+std::unique_ptr<views::StatusIconLinux> GtkUi::CreateLinuxStatusIcon(
     const gfx::ImageSkia& image,
     const base::string16& tool_tip) const {
   if (AppIndicatorIcon::CouldOpen()) {
     ++indicators_count;
     return std::unique_ptr<views::StatusIconLinux>(new AppIndicatorIcon(
         base::StringPrintf("%s%d", kAppIndicatorIdPrefix, indicators_count),
         image, tool_tip));
   } else {
     return std::unique_ptr<views::StatusIconLinux>(
         new Gtk2StatusIcon(image, tool_tip));
   }
 }
 
-gfx::Image Gtk2UI::GetIconForContentType(const std::string& content_type,
-                                         int size) const {
+gfx::Image GtkUi::GetIconForContentType(const std::string& content_type,
+                                        int size) const {
   // This call doesn't take a reference.
   GtkIconTheme* theme = gtk_icon_theme_get_default();
 
   std::string content_types[] = {content_type, kUnknownContentType};
 
   for (size_t i = 0; i < arraysize(content_types); ++i) {
     ScopedGIcon icon(g_content_type_get_icon(content_types[i].c_str()));
     ScopedGtkIconInfo icon_info(gtk_icon_theme_lookup_by_gicon(
         theme, icon.get(), size,
         static_cast<GtkIconLookupFlags>(GTK_ICON_LOOKUP_FORCE_SIZE)));
     if (!icon_info)
       continue;
     ScopedGdkPixbuf pixbuf(gtk_icon_info_load_icon(icon_info.get(), NULL));
     if (!pixbuf)
       continue;
 
     SkBitmap bitmap = GdkPixbufToImageSkia(pixbuf.get());
     DCHECK_EQ(size, bitmap.width());
     DCHECK_EQ(size, bitmap.height());
     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(
+std::unique_ptr<views::Border> GtkUi::CreateNativeBorder(
     views::LabelButton* owning_button,
     std::unique_ptr<views::LabelButtonBorder> border) {
   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());
 
@@ skipping 48 matching lines @@
       std::string idr = is_blue ? paintstate[i].idr_blue : paintstate[i].idr;
       painter = new GtkButtonPainter(idr);
     }
 
     gtk_border->SetPainter(paintstate[i].focus, paintstate[i].state, painter);
   }
 
   return std::move(gtk_border);
 }
 
-void Gtk2UI::AddWindowButtonOrderObserver(
+void GtkUi::AddWindowButtonOrderObserver(
     views::WindowButtonOrderObserver* observer) {
   if (!leading_buttons_.empty() || !trailing_buttons_.empty()) {
     observer->OnWindowButtonOrderingChange(leading_buttons_, trailing_buttons_);
   }
 
   observer_list_.AddObserver(observer);
 }
 
-void Gtk2UI::RemoveWindowButtonOrderObserver(
+void GtkUi::RemoveWindowButtonOrderObserver(
     views::WindowButtonOrderObserver* observer) {
   observer_list_.RemoveObserver(observer);
 }
 
-void Gtk2UI::SetWindowButtonOrdering(
+void GtkUi::SetWindowButtonOrdering(
     const std::vector<views::FrameButton>& leading_buttons,
     const std::vector<views::FrameButton>& trailing_buttons) {
   leading_buttons_ = leading_buttons;
   trailing_buttons_ = trailing_buttons;
 
   for (views::WindowButtonOrderObserver& observer : observer_list_)
     observer.OnWindowButtonOrderingChange(leading_buttons_, trailing_buttons_);
 }
 
-void Gtk2UI::SetNonClientMiddleClickAction(NonClientMiddleClickAction action) {
+void GtkUi::SetNonClientMiddleClickAction(NonClientMiddleClickAction action) {
   middle_click_action_ = action;
 }
 
-std::unique_ptr<ui::LinuxInputMethodContext> Gtk2UI::CreateInputMethodContext(
+std::unique_ptr<ui::LinuxInputMethodContext> GtkUi::CreateInputMethodContext(
     ui::LinuxInputMethodContextDelegate* delegate,
     bool is_simple) const {
   return std::unique_ptr<ui::LinuxInputMethodContext>(
       new X11InputMethodContextImplGtk2(delegate, is_simple));
 }
 
-gfx::FontRenderParams Gtk2UI::GetDefaultFontRenderParams() const {
+gfx::FontRenderParams GtkUi::GetDefaultFontRenderParams() const {
   static gfx::FontRenderParams params = GetGtkFontRenderParams();
   return params;
 }
 
-void Gtk2UI::GetDefaultFontDescription(
-    std::string* family_out,
-    int* size_pixels_out,
-    int* style_out,
-    gfx::Font::Weight* weight_out,
-    gfx::FontRenderParams* params_out) const {
+void GtkUi::GetDefaultFontDescription(std::string* family_out,
+                                      int* size_pixels_out,
+                                      int* style_out,
+                                      gfx::Font::Weight* weight_out,
+                                      gfx::FontRenderParams* params_out) const {
   *family_out = default_font_family_;
   *size_pixels_out = default_font_size_pixels_;
   *style_out = default_font_style_;
   *weight_out = default_font_weight_;
   *params_out = default_font_render_params_;
 }
 
-ui::SelectFileDialog* Gtk2UI::CreateSelectFileDialog(
+ui::SelectFileDialog* GtkUi::CreateSelectFileDialog(
     ui::SelectFileDialog::Listener* listener,
     ui::SelectFilePolicy* policy) const {
   return SelectFileDialogImpl::Create(listener, policy);
 }
 
-bool Gtk2UI::UnityIsRunning() {
+bool GtkUi::UnityIsRunning() {
   return unity::IsRunning();
 }
 
 views::LinuxUI::NonClientMiddleClickAction
-Gtk2UI::GetNonClientMiddleClickAction() {
+GtkUi::GetNonClientMiddleClickAction() {
   return middle_click_action_;
 }
 
-void Gtk2UI::NotifyWindowManagerStartupComplete() {
+void GtkUi::NotifyWindowManagerStartupComplete() {
   // TODO(port) Implement this using _NET_STARTUP_INFO_BEGIN/_NET_STARTUP_INFO
   // from http://standards.freedesktop.org/startup-notification-spec/ instead.
   gdk_notify_startup_complete();
 }
 
-bool Gtk2UI::MatchEvent(const ui::Event& event,
-                        std::vector<ui::TextEditCommandAuraLinux>* commands) {
+bool GtkUi::MatchEvent(const ui::Event& event,
+                       std::vector<ui::TextEditCommandAuraLinux>* commands) {
   // Ensure that we have a keyboard handler.
   if (!key_bindings_handler_)
     key_bindings_handler_.reset(new Gtk2KeyBindingsHandler);
 
   return key_bindings_handler_->MatchEvent(event, commands);
 }
 
-void Gtk2UI::SetScrollbarColors() {
+void GtkUi::SetScrollbarColors() {
   thumb_active_color_ = SkColorSetRGB(244, 244, 244);
   thumb_inactive_color_ = SkColorSetRGB(234, 234, 234);
   track_color_ = SkColorSetRGB(211, 211, 211);
 
   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() {
+void GtkUi::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.
 
   SkColor toolbar_color =
       native_theme_->GetSystemColor(ui::NativeTheme::kColorId_DialogBackground);
   SkColor label_color = native_theme_->GetSystemColor(
       ui::NativeTheme::kColorId_LabelEnabledColor);
 
@@ skipping 71 matching lines @@
       native_theme_->GetSystemColor(
           ui::NativeTheme::kColorId_ThrobberWaitingColor);
 
 #if GTK_MAJOR_VERSION > 2
   colors_[ThemeProperties::COLOR_TOOLBAR_BOTTOM_SEPARATOR] =
       colors_[ThemeProperties::COLOR_DETACHED_BOOKMARK_BAR_SEPARATOR] =
           GetBorderColor("GtkToolbar.primary-toolbar.toolbar");
 #endif
 }
 
-void Gtk2UI::LoadCursorTheme() {
+void GtkUi::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);
 
   if (theme)
     XcursorSetTheme(gfx::GetXDisplay(), theme);
   if (size)
     XcursorSetDefaultSize(gfx::GetXDisplay(), size);
 
   g_free(theme);
 }
 
-void Gtk2UI::BuildFrameColors() {
+void GtkUi::BuildFrameColors() {
 #if GTK_MAJOR_VERSION == 2
   color_utils::HSL kDefaultFrameShift = {-1, -1, 0.4};
   SkColor frame_color =
       native_theme_->GetSystemColor(ui::NativeTheme::kColorId_WindowBackground);
   frame_color = color_utils::HSLShift(frame_color, kDefaultFrameShift);
   GetChromeStyleColor("frame-color", &frame_color);
   colors_[ThemeProperties::COLOR_FRAME] = frame_color;
 
   GtkStyle* style = gtk_rc_get_style(fake_window_);
   SkColor temp_color = color_utils::HSLShift(
       GdkColorToSkColor(style->bg[GTK_STATE_INSENSITIVE]), kDefaultFrameShift);
   GetChromeStyleColor("inactive-frame-color", &temp_color);
   colors_[ThemeProperties::COLOR_FRAME_INACTIVE] = temp_color;
 
   temp_color = color_utils::HSLShift(frame_color, kDefaultTintFrameIncognito);
   GetChromeStyleColor("incognito-frame-color", &temp_color);
   colors_[ThemeProperties::COLOR_FRAME_INCOGNITO] = temp_color;
 
   temp_color =
       color_utils::HSLShift(frame_color, kDefaultTintFrameIncognitoInactive);
   GetChromeStyleColor("incognito-inactive-frame-color", &temp_color);
   colors_[ThemeProperties::COLOR_FRAME_INCOGNITO_INACTIVE] = temp_color;
 #else
   // TODO(thomasanderson): Render a GtkHeaderBar directly.
-  SkColor color_frame = GetBGColor(".headerbar.header-bar.titlebar");
+  SkColor color_frame = GetBgColor(".headerbar.header-bar.titlebar");
   SkColor color_frame_inactive =
-      GetBGColor(".headerbar.header-bar.titlebar:backdrop");
+      GetBgColor(".headerbar.header-bar.titlebar:backdrop");
   colors_[ThemeProperties::COLOR_FRAME] = color_frame;
   colors_[ThemeProperties::COLOR_FRAME_INACTIVE] = color_frame_inactive;
   colors_[ThemeProperties::COLOR_FRAME_INCOGNITO] =
       color_utils::HSLShift(color_frame, kDefaultTintFrameIncognito);
   colors_[ThemeProperties::COLOR_FRAME_INCOGNITO_INACTIVE] =
       color_utils::HSLShift(color_frame_inactive, kDefaultTintFrameIncognito);
 #endif
 }
 
-void Gtk2UI::GetNormalButtonTintHSL(color_utils::HSL* tint) const {
+void GtkUi::GetNormalButtonTintHSL(color_utils::HSL* tint) const {
   SkColor accent_color = native_theme_->GetSystemColor(
       ui::NativeTheme::kColorId_ProminentButtonColor);
   SkColor text_color = native_theme_->GetSystemColor(
       ui::NativeTheme::kColorId_LabelEnabledColor);
   SkColor base_color =
       native_theme_->GetSystemColor(ui::NativeTheme::kColorId_DialogBackground);
 
   PickButtonTintFromColors(accent_color, text_color, base_color, tint);
 }
 
-void Gtk2UI::GetNormalEntryForegroundHSL(color_utils::HSL* tint) const {
+void GtkUi::GetNormalEntryForegroundHSL(color_utils::HSL* tint) const {
   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 {
+void GtkUi::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 = native_theme_->GetSystemColor(
       ui::NativeTheme::kColorId_TextfieldSelectionColor);
 
   color_utils::SkColorToHSL(color, tint);
 }
 
-void Gtk2UI::UpdateDefaultFont() {
+void GtkUi::UpdateDefaultFont() {
   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), ",",
@@ skipping 23 matching lines @@
     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 {
+bool GtkUi::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() {
+void GtkUi::ResetStyle() {
   LoadGtkValues();
   native_theme_->NotifyObservers();
 }
 
-void Gtk2UI::UpdateDeviceScaleFactor() {
+void GtkUi::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 {
+float GtkUi::GetDeviceScaleFactor() const {
   return device_scale_factor_;
 }
 
 }  // namespace libgtkui
 
-views::LinuxUI* BuildGtk2UI() {
-  return new libgtkui::Gtk2UI;
+views::LinuxUI* BuildGtkUi() {
+  return new libgtkui::GtkUi;
 }