Gtk3 UI: Rename files in libgtkui containing gtk2 in their name

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/gtk2_ui.h"
+#include "chrome/browser/ui/libgtkui/gtk_ui.h"
 
 #include <math.h>
 #include <pango/pango.h>
 #include <X11/Xcursor/Xcursor.h>
 #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/gtk2_event_loop.h"
-#include "chrome/browser/ui/libgtkui/gtk2_key_bindings_handler.h"
-#include "chrome/browser/ui/libgtkui/gtk2_status_icon.h"
-#include "chrome/browser/ui/libgtkui/gtk2_util.h"
-#include "chrome/browser/ui/libgtkui/native_theme_gtk2.h"
-#include "chrome/browser/ui/libgtkui/print_dialog_gtk2.h"
-#include "chrome/browser/ui/libgtkui/printing_gtk2_util.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_gtk2.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_gtk2.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 "third_party/skia/include/core/SkBitmap.h"
 #include "third_party/skia/include/core/SkCanvas.h"
 #include "third_party/skia/include/core/SkColor.h"
 #include "third_party/skia/include/core/SkShader.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "ui/display/display.h"
 #include "ui/gfx/canvas.h"
 #include "ui/gfx/geometry/rect.h"
@@ skipping 76 matching lines @@
 
     gtk_widget_set_size_request(button, width, height);
     gtk_container_add(GTK_CONTAINER(window), button);
 
     if (is_blue_)
       TurnButtonBlue(button);
 
     gtk_widget_show_all(window);
 
     cairo_surface_t* surface = cairo_image_surface_create_for_data(
-        static_cast<unsigned char*>(border.getAddr(0, 0)),
-        CAIRO_FORMAT_ARGB32, width, height, width * 4);
+        static_cast<unsigned char*>(border.getAddr(0, 0)), CAIRO_FORMAT_ARGB32,
+        width, height, width * 4);
     cairo_t* cr = cairo_create(surface);
 
 #if GTK_MAJOR_VERSION == 2
     if (focus_)
       GTK_WIDGET_SET_FLAGS(button, GTK_HAS_FOCUS);
 
     int w, h;
     GdkPixmap* pixmap;
 
     {
@@ skipping 10 matching lines @@
     gdk_cairo_set_source_pixbuf(cr, pixbuf, 0, 0);
     cairo_paint(cr);
 
     g_object_unref(pixbuf);
     g_object_unref(pixmap);
 #else
     gtk_widget_draw(button, cr);
 
     // There's probably a better way to do this
     if (focus_)
-      gtk_render_focus(gtk_widget_get_style_context(button), cr, 0, 0,
-                       width, height);
+      gtk_render_focus(gtk_widget_get_style_context(button), cr, 0, 0, width,
+                       height);
 #endif
 
     cairo_destroy(cr);
     cairo_surface_destroy(surface);
 
     gtk_widget_destroy(window);
 
     return gfx::ImageSkiaRep(border, scale);
   }
 
@@ skipping 19 matching lines @@
     canvas->DrawImageInt(image, 0, 0);
   }
 
  private:
   std::string idr_;
 
   DISALLOW_COPY_AND_ASSIGN(GtkButtonPainter);
 };
 
 struct GObjectDeleter {
-  void operator()(void* ptr) {
-    g_object_unref(ptr);
-  }
+  void operator()(void* ptr) { g_object_unref(ptr); }
 };
 struct GtkIconInfoDeleter {
   void operator()(GtkIconInfo* ptr) {
     G_GNUC_BEGIN_IGNORE_DEPRECATIONS
     gtk_icon_info_free(ptr);
     G_GNUC_END_IGNORE_DEPRECATIONS
   }
 };
 typedef std::unique_ptr<GIcon, GObjectDeleter> ScopedGIcon;
 typedef std::unique_ptr<GtkIconInfo, GtkIconInfoDeleter> ScopedGtkIconInfo;
 typedef std::unique_ptr<GdkPixbuf, GObjectDeleter> ScopedGdkPixbuf;
 
 // 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";
 
 // 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 kDefaultTintFrameIncognito = {-1, 0.2f, 0.35f};
+const color_utils::HSL kDefaultTintFrameIncognitoInactive = {-1, 0.3f, 0.6f};
 
 #if GTK_MAJOR_VERSION == 3
-const color_utils::HSL kDefaultTintFrameInactive = { -1, -1, 0.75f };
+const color_utils::HSL kDefaultTintFrameInactive = {-1, -1, 0.75f};
 #endif  // GTK_MAJOR_VERSION == 3
 
 // 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
 // have a dark window background (with light text) and a light text entry (with
 // dark text) will get better icons with this separated out.
 void PickButtonTintFromColors(SkColor accent_color,
@@ skipping 169 matching lines @@
 }
 
 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),
-                         this);
-  g_signal_connect_after(settings,
-                         "notify::gtk-icon-theme-name",
-                         G_CALLBACK(OnThemeChanged),
-                         this);
+  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 defined(ENABLE_BASIC_PRINTING)
   printing::PrintingContextLinux::SetCreatePrintDialogFunction(
       &PrintDialogGtk2::CreatePrintDialog);
   printing::PrintingContextLinux::SetPdfPaperSizeFunction(
       &GetPdfPaperSizeDeviceUnitsGtk);
@@ skipping 145 matching lines @@
     ++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 Gtk2UI::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
-  };
+  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)));
+    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);
@@ skipping 13 matching lines @@
       new views::LabelButtonAssetBorder(owning_button->style()));
 
   gtk_border->set_insets(border->GetInsets());
 
   static struct {
     const char* idr;
     const char* idr_blue;
     bool focus;
     views::Button::ButtonState state;
   } const paintstate[] = {
-    { "IDR_BUTTON_NORMAL",
-      "IDR_BLUE_BUTTON_NORMAL",
-      false, views::Button::STATE_NORMAL, },
-    { "IDR_BUTTON_HOVER",
-      "IDR_BLUE_BUTTON_HOVER",
-      false, views::Button::STATE_HOVERED, },
-    { "IDR_BUTTON_PRESSED",
-      "IDR_BLUE_BUTTON_PRESSED",
-      false, views::Button::STATE_PRESSED, },
-    { "IDR_BUTTON_DISABLED",
-      "IDR_BLUE_BUTTON_DISABLED",
-      false, views::Button::STATE_DISABLED, },
+      {
+          "IDR_BUTTON_NORMAL", "IDR_BLUE_BUTTON_NORMAL", false,
+          views::Button::STATE_NORMAL,
+      },
+      {
+          "IDR_BUTTON_HOVER", "IDR_BLUE_BUTTON_HOVER", false,
+          views::Button::STATE_HOVERED,
+      },
+      {
+          "IDR_BUTTON_PRESSED", "IDR_BLUE_BUTTON_PRESSED", false,
+          views::Button::STATE_PRESSED,
+      },
+      {
+          "IDR_BUTTON_DISABLED", "IDR_BLUE_BUTTON_DISABLED", false,
+          views::Button::STATE_DISABLED,
+      },
 
-    { "IDR_BUTTON_FOCUSED_NORMAL",
-      "IDR_BLUE_BUTTON_FOCUSED_NORMAL",
-      true, views::Button::STATE_NORMAL, },
-    { "IDR_BUTTON_FOCUSED_HOVER",
-      "IDR_BLUE_BUTTON_FOCUSED_HOVER",
-      true, views::Button::STATE_HOVERED, },
-    { "IDR_BUTTON_FOCUSED_PRESSED",
-      "IDR_BLUE_BUTTON_FOCUSED_PRESSED",
-      true, views::Button::STATE_PRESSED, },
-    { "IDR_BUTTON_DISABLED",
-      "IDR_BLUE_BUTTON_DISABLED",
-      true, views::Button::STATE_DISABLED, },
+      {
+          "IDR_BUTTON_FOCUSED_NORMAL", "IDR_BLUE_BUTTON_FOCUSED_NORMAL", true,
+          views::Button::STATE_NORMAL,
+      },
+      {
+          "IDR_BUTTON_FOCUSED_HOVER", "IDR_BLUE_BUTTON_FOCUSED_HOVER", true,
+          views::Button::STATE_HOVERED,
+      },
+      {
+          "IDR_BUTTON_FOCUSED_PRESSED", "IDR_BLUE_BUTTON_FOCUSED_PRESSED", true,
+          views::Button::STATE_PRESSED,
+      },
+      {
+          "IDR_BUTTON_DISABLED", "IDR_BLUE_BUTTON_DISABLED", true,
+          views::Button::STATE_DISABLED,
+      },
   };
 
   bool is_blue =
       owning_button->GetClassName() == views::BlueButton::kViewClassName;
 
   for (unsigned i = 0; i < arraysize(paintstate); i++) {
     views::Painter* painter = nullptr;
 
     if (border->PaintsButtonState(paintstate[i].focus, paintstate[i].state)) {
       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(
     views::WindowButtonOrderObserver* observer) {
   if (!leading_buttons_.empty() || !trailing_buttons_.empty()) {
-    observer->OnWindowButtonOrderingChange(leading_buttons_,
-                                           trailing_buttons_);
+    observer->OnWindowButtonOrderingChange(leading_buttons_, trailing_buttons_);
   }
 
   observer_list_.AddObserver(observer);
 }
 
 void Gtk2UI::RemoveWindowButtonOrderObserver(
     views::WindowButtonOrderObserver* observer) {
   observer_list_.RemoveObserver(observer);
 }
 
@@ skipping 109 matching lines @@
   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(
-          ui::NativeTheme::kColorId_TextfieldDefaultBackground);
+  SkColor ntp_background = theme->GetSystemColor(
+      ui::NativeTheme::kColorId_TextfieldDefaultBackground);
   SkColor ntp_foreground =
-      theme->GetSystemColor(
-          ui::NativeTheme::kColorId_TextfieldDefaultColor);
+      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.
 
@@ skipping 10 matching lines @@
   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(
-          ui::NativeTheme::kColorId_TextfieldSelectionBackgroundFocused);
+  active_selection_bg_color_ = theme->GetSystemColor(
+      ui::NativeTheme::kColorId_TextfieldSelectionBackgroundFocused);
   active_selection_fg_color_ =
-      theme->GetSystemColor(
-          ui::NativeTheme::kColorId_TextfieldSelectionColor);
-  inactive_selection_bg_color_ =
-      theme->GetSystemColor(
-          ui::NativeTheme::kColorId_TextfieldReadOnlyBackground);
+      theme->GetSystemColor(ui::NativeTheme::kColorId_TextfieldSelectionColor);
+  inactive_selection_bg_color_ = theme->GetSystemColor(
+      ui::NativeTheme::kColorId_TextfieldReadOnlyBackground);
   inactive_selection_fg_color_ =
-      theme->GetSystemColor(
-          ui::NativeTheme::kColorId_TextfieldReadOnlyColor);
+      theme->GetSystemColor(ui::NativeTheme::kColorId_TextfieldReadOnlyColor);
 
   colors_[ThemeProperties::COLOR_TAB_THROBBER_SPINNING] =
       theme->GetSystemColor(ui::NativeTheme::kColorId_ThrobberSpinningColor);
   colors_[ThemeProperties::COLOR_TAB_THROBBER_WAITING] =
       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);
 
   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 };
+  color_utils::HSL kDefaultFrameShift = {-1, -1, 0.4};
   SkColor frame_color =
       theme->GetSystemColor(ui::NativeTheme::kColorId_WindowBackground);
   frame_color = color_utils::HSLShift(frame_color, kDefaultFrameShift);
   theme->GetChromeStyleColor("frame-color", &frame_color);
   colors_[ThemeProperties::COLOR_FRAME] = frame_color;
 
   GtkStyle* style = gtk_rc_get_style(theme->GetWindow());
   SkColor temp_color = color_utils::HSLShift(
-      GdkColorToSkColor(style->bg[GTK_STATE_INSENSITIVE]),
-      kDefaultFrameShift);
+      GdkColorToSkColor(style->bg[GTK_STATE_INSENSITIVE]), kDefaultFrameShift);
   theme->GetChromeStyleColor("inactive-frame-color", &temp_color);
   colors_[ThemeProperties::COLOR_FRAME_INACTIVE] = temp_color;
 
-  temp_color = color_utils::HSLShift(
-      frame_color,
-      kDefaultTintFrameIncognito);
+  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);
+  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
   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 44 matching lines @@
   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);
+      theme->GetSystemColor(ui::NativeTheme::kColorId_LabelEnabledColor);
   SkColor base_color =
       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(
-          ui::NativeTheme::kColorId_TextfieldDefaultBackground);
+      theme->GetSystemColor(ui::NativeTheme::kColorId_TextfieldDefaultColor);
+  SkColor base_color = 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(
-          ui::NativeTheme::kColorId_TextfieldSelectionColor);
+  SkColor color = NativeThemeGtk2::instance()->GetSystemColor(
+      ui::NativeTheme::kColorId_TextfieldSelectionColor);
 
   color_utils::SkColorToHSL(color, tint);
 }
 
 void Gtk2UI::UpdateDefaultFont() {
-  PangoContext* pc = gtk_widget_get_pango_context(
-    NativeThemeGtk2::instance()->GetLabel());
+  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,
-                                     base::SPLIT_WANT_ALL);
+  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);
+                               static_cast<double>(PANGO_SCALE);
     default_font_size_pixels_ = static_cast<int>(
         GetPixelsInPoint(device_scale_factor_) * size_points + 0.5);
     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)
@@ skipping 23 matching lines @@
   // 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 libgtkui
 
 views::LinuxUI* BuildGtk2UI() {
   return new libgtkui::Gtk2UI;
 }