Linux UI: Dynamically respond to changes in the scale factor

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 <X11/Xcursor/Xcursor.h>
 #include <dlfcn.h>
 #include <math.h>
 #include <pango/pango.h>
@@ skipping 39 matching lines @@
 #include "ui/gfx/geometry/size.h"
 #include "ui/gfx/image/image.h"
 #include "ui/gfx/image/image_skia_source.h"
 #include "ui/gfx/skbitmap_operations.h"
 #include "ui/gfx/skia_util.h"
 #include "ui/gfx/x/x11_types.h"
 #include "ui/native_theme/native_theme.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/device_scale_factor_observer.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)
@@ skipping 235 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;
 }
 
-float GetRawDeviceScaleFactor() {
-  if (display::Display::HasForceDeviceScaleFactor())
-    return display::Display::GetForcedDeviceScaleFactor();
-
-  GdkScreen* screen = gdk_screen_get_default();
-  gint scale = gdk_screen_get_monitor_scale_factor(
-      screen, gdk_screen_get_primary_monitor(screen));
-  gdouble resolution = gdk_screen_get_resolution(screen);
-  return resolution <= 0 ? scale : resolution * scale / kDefaultDPI;
-}
-
 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;
@@ skipping 68 matching lines @@
           dlsym(GetGdkSharedLibrary(), "gdk_set_allowed_backends"));
   if (GtkVersionCheck(3, 10))
     DCHECK(_gdk_set_allowed_backends);
   if (_gdk_set_allowed_backends)
     _gdk_set_allowed_backends("x11");
 #endif
   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();
-  (void)fake_window_;  // Silence the unused warning.
+  fake_window_ = gtk_window_new(GTK_WINDOW_TOPLEVEL);
 #else
 #error "Unsupported GTK version"
 #endif
+  gtk_widget_realize(fake_window_);
 }
 
 GtkUi::~GtkUi() {
-#if GTK_MAJOR_VERSION == 2
   gtk_widget_destroy(fake_window_);
-#endif
 }
 
 void OnThemeChanged(GObject* obj, GParamSpec* param, GtkUi* gtkui) {
   gtkui->ResetStyle();
 }
 
 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);
 
+  GdkScreen* screen = gdk_screen_get_default();
+  // Listen for DPI changes.
+  g_signal_connect_after(screen, "notify::resolution",
+                         G_CALLBACK(OnDeviceScaleFactorMaybeChangedThunk),
+                         this);
+  // Listen for scale factor changes.  We would prefer to listen on
+  // |screen|, but there is no scale-factor property, so use an
+  // unmapped window instead.
+  g_signal_connect(fake_window_, "notify::scale-factor",
+                   G_CALLBACK(OnDeviceScaleFactorMaybeChangedThunk), this);
+
   LoadGtkValues();
 
 #if BUILDFLAG(ENABLE_BASIC_PRINTING)
   printing::PrintingContextLinux::SetCreatePrintDialogFunction(
       &PrintDialogGtk2::CreatePrintDialog);
   printing::PrintingContextLinux::SetPdfPaperSizeFunction(
       &GetPdfPaperSizeDeviceUnitsGtk);
 #endif
 
 #if defined(USE_GCONF)
@@ skipping 241 matching lines @@
 
   return std::move(gtk_border);
 }
 
 void GtkUi::AddWindowButtonOrderObserver(
     views::WindowButtonOrderObserver* observer) {
   if (!leading_buttons_.empty() || !trailing_buttons_.empty()) {
     observer->OnWindowButtonOrderingChange(leading_buttons_, trailing_buttons_);
   }
 
-  observer_list_.AddObserver(observer);
+  window_button_order_observer_list_.AddObserver(observer);
 }
 
 void GtkUi::RemoveWindowButtonOrderObserver(
     views::WindowButtonOrderObserver* observer) {
-  observer_list_.RemoveObserver(observer);
+  window_button_order_observer_list_.RemoveObserver(observer);
 }
 
 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_)
+  for (views::WindowButtonOrderObserver& observer :
+       window_button_order_observer_list_) {
     observer.OnWindowButtonOrderingChange(leading_buttons_, trailing_buttons_);
+  }
 }
 
 void GtkUi::SetNonClientMiddleClickAction(NonClientMiddleClickAction action) {
   middle_click_action_ = action;
 }
 
 std::unique_ptr<ui::LinuxInputMethodContext> GtkUi::CreateInputMethodContext(
     ui::LinuxInputMethodContextDelegate* delegate,
     bool is_simple) const {
   return std::unique_ptr<ui::LinuxInputMethodContext>(
@@ skipping 31 matching lines @@
 GtkUi::GetNonClientMiddleClickAction() {
   return middle_click_action_;
 }
 
 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();
 }
 
+void GtkUi::AddDeviceScaleFactorObserver(
+    views::DeviceScaleFactorObserver* observer) {
+  device_scale_factor_observer_list_.AddObserver(observer);
+}
+
+void GtkUi::RemoveDeviceScaleFactorObserver(
+    views::DeviceScaleFactorObserver* observer) {
+  device_scale_factor_observer_list_.RemoveObserver(observer);
+}
+
 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 GtkUi::OnDeviceScaleFactorMaybeChanged(void*, GParamSpec*) {
+  UpdateDeviceScaleFactor();
+}
+
 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_);
 }
 
@@ skipping 238 matching lines @@
 #endif
 
   return false;
 }
 
 void GtkUi::ResetStyle() {
   LoadGtkValues();
   native_theme_->NotifyObservers();
 }
 
+float GtkUi::GetRawDeviceScaleFactor() {
+  if (display::Display::HasForceDeviceScaleFactor())
+    return display::Display::GetForcedDeviceScaleFactor();
+
+  GdkScreen* screen = gdk_screen_get_default();
+  gint scale = gtk_widget_get_scale_factor(fake_window_);
+  gdouble resolution = gdk_screen_get_resolution(screen);
+  return resolution <= 0 ? scale : resolution * scale / kDefaultDPI;
+}
+
 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();
+  float old_device_scale_factor = device_scale_factor_;
   // Blacklist scaling factors <120% (crbug.com/484400) and round
   // to 1 decimal to prevent rendering problems (crbug.com/485183).
+  float scale = GetRawDeviceScaleFactor();
   device_scale_factor_ = scale < 1.2f ? 1.0f : roundf(scale * 10) / 10;
+  if (device_scale_factor_ != old_device_scale_factor) {
+    for (views::DeviceScaleFactorObserver& observer :
+         device_scale_factor_observer_list_) {
+      observer.OnDeviceScaleFactorChanged();
+    }
+  }
   UpdateDefaultFont();
 }
 
 float GtkUi::GetDeviceScaleFactor() const {
   return device_scale_factor_;
 }
 
 }  // namespace libgtkui
 
 views::LinuxUI* BuildGtkUi() {
   return new libgtkui::GtkUi;
 }