[linux] Allow font to use below 1.0f scale

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"
@@ skipping 57 matching lines @@
 // linux/debian_wheezy_i386-sysroot/usr/include/linux/stddef.h redefines NULL
 // to 0, which breaks -Wsentinel. Get back the normal definition of NULL.
 // TODO(thakis): Remove this once we update sysroots.
 #define __need_NULL
 #include <stddef.h>
 
 namespace libgtkui {
 
 namespace {
 
+const double kDefaultDPI = 96;
+
 class GtkButtonImageSource : public gfx::ImageSkiaSource {
  public:
   GtkButtonImageSource(const char* idr_string, gfx::Size size)
       : width_(size.width()), height_(size.height()) {
     is_blue_ = !!strstr(idr_string, "IDR_BLUE");
     focus_ = !!strstr(idr_string, "_FOCUSED_");
 
     if (strstr(idr_string, "_DISABLED")) {
       state_ = ui::NativeTheme::kDisabled;
     } else if (strstr(idr_string, "_HOVER")) {
@@ skipping 246 matching lines @@
     LOG(WARNING) << "Unexpected gtk-xft-rgba \"" << rgba << "\"";
     params.subpixel_rendering = gfx::FontRenderParams::SUBPIXEL_RENDERING_NONE;
   }
 
   g_free(hint_style);
   g_free(rgba);
 
   return params;
 }
 
-double GetDPI() {
-  // Linux chrome currently does not support dynamic DPI changes.
-  // Keep using the first value detected.
-  static double dpi = -1.f;
-  if (dpi < 0) {
-    const double kDefaultDPI = 96;
+double GetDpi() {
+  if (display::Display::HasForceDeviceScaleFactor())
+    return display::Display::GetForcedDeviceScaleFactor() * kDefaultDPI;
 
-    if (display::Display::HasForceDeviceScaleFactor()) {
-      dpi = display::Display::GetForcedDeviceScaleFactor() * kDefaultDPI;
-      return dpi;
-    }
+  GtkSettings* gtk_settings = gtk_settings_get_default();
+  CHECK(gtk_settings);
+  gint gtk_dpi = -1;
+  g_object_get(gtk_settings, "gtk-xft-dpi", &gtk_dpi, NULL);
 
-    GtkSettings* gtk_settings = gtk_settings_get_default();
-    CHECK(gtk_settings);
-    gint gtk_dpi = -1;
-    g_object_get(gtk_settings, "gtk-xft-dpi", &gtk_dpi, NULL);
-
-    // GTK multiplies the DPI by 1024 before storing it.
-    dpi = (gtk_dpi > 0) ? gtk_dpi / 1024.0 : kDefaultDPI;
-
-    // DSF is always >=1.0 on win/cros and lower DSF has never been considered
-    // nor tested.
-    dpi = std::max(kDefaultDPI, dpi);
-  }
-  return dpi;
+  // GTK multiplies the DPI by 1024 before storing it.
+  return (gtk_dpi > 0) ? gtk_dpi / 1024.0 : kDefaultDPI;
 }
 
-// Queries GTK for its font DPI setting and returns the number of pixels in a
-// point.
-double GetPixelsInPoint(float device_scale_factor) {
-  double dpi = GetDPI();
+float GetRawDeviceScaleFactor() {
+  if (display::Display::HasForceDeviceScaleFactor())
+    return display::Display::GetForcedDeviceScaleFactor();
+  return GetDpi() / kDefaultDPI;
+}
+
+// Returns the font size for the *raw* device scale factor in points.
+// The |device_scale_factor| is used to cancel the scale to be applied by UI
+// and to compensate the scale when the device_scale_factor is floored.
+double GetFontSizePixelsInPoint(float device_scale_factor) {

[Evan Stade, 2016/11/03 16:38:03]

perhaps this param could be called ui_scale_factor or ui_dsf to be clearer about
its role?

[oshima, 2016/11/05 15:15:05]

changed to ui_device_scale_factor.

+  // There are 72 points in an inch.
+  double point = GetDpi() / 72.0;
 
   // Take device_scale_factor into account — if Chrome already scales the
   // entire UI up by 2x, we should not also scale up.
-  dpi /= device_scale_factor;
+  point /= device_scale_factor;
 
-  // There are 72 points in an inch.
-  return dpi / 72.0;
+  // Allow the scale lower than 1.0 only for fonts. Don't always use
+  // the raw value however, beacuse the 1.0~1.3 is rounded to 1.0.

[Evan Stade, 2016/11/03 16:38:03]

why not allow users to bump font size slightly? The drawing issues in the 1-1.3
range don't apply to fonts, do they?

also nit: s/beacuse/because

[oshima, 2016/11/05 15:15:05]

I want to keep the current behavior for dsf>1 case, at least for now.

With new scaling scheme in blink, I think we can relax this but I'll
do that in a separate CL.

+  float raw_scale = GetRawDeviceScaleFactor();
+  if (raw_scale < 1.0f)
+    return point * raw_scale / device_scale_factor;
+  return point;
 }
 
 views::LinuxUI::NonClientMiddleClickAction GetDefaultMiddleClickAction() {
   std::unique_ptr<base::Environment> env(base::Environment::Create());
   switch (base::nix::GetDesktopEnvironment(env.get())) {
     case base::nix::DESKTOP_ENVIRONMENT_KDE4:
     case base::nix::DESKTOP_ENVIRONMENT_KDE5:
       // Starting with KDE 4.4, windows' titlebars can be dragged with the
       // middle mouse button to create tab groups. We don't support that in
       // 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()
     : 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) {
+      middle_click_action_(GetDefaultMiddleClickAction()) {
   GtkInitFromCommandLine(*base::CommandLine::ForCurrentProcess());
 }
 
 Gtk2UI::~Gtk2UI() {}
 
 void OnThemeChanged(GObject* obj, GParamSpec* param, Gtk2UI* gtkui) {
   gtkui->ResetStyle();
 }
 
 void Gtk2UI::Initialize() {
@@ skipping 377 matching lines @@
   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);
 
-  UpdateDefaultFont();
+  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
@@ skipping 199 matching lines @@
     // 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>(
-        GetPixelsInPoint(device_scale_factor_) * size_points + 0.5);
-    query.point_size = static_cast<int>(size_points);
+        GetFontSizePixelsInPoint(GetDeviceScaleFactor()) * 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;
 }
 
 void Gtk2UI::ResetStyle() {
   LoadGtkValues();
   NativeThemeGtk2::instance()->NotifyObservers();
 }
 
-void Gtk2UI::UpdateDeviceScaleFactor(float device_scale_factor) {
-  device_scale_factor_ = device_scale_factor;
+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 <130% (crbug.com/484400) and round
+  // to 1 decimal to prevent rendering problems (crbug.com/485183).
+  device_scale_factor_ = scale < 1.3f ? 1.0f : roundf(scale * 10) / 10;
   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;
+  return device_scale_factor_;
 }
 
 }  // namespace libgtkui
 
 views::LinuxUI* BuildGtk2UI() {
   return new libgtkui::Gtk2UI;
 }