Linux UI: Dynamically respond to changes in the scale factor

ui/views/widget/desktop_aura/desktop_screen_x11.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 "ui/views/widget/desktop_aura/desktop_screen_x11.h"
 
 #include <X11/extensions/Xrandr.h>
 #include <X11/Xlib.h>
 
 // It clashes with out RootWindow.
 #undef RootWindow
 
 #include "base/logging.h"
+#include "base/threading/thread_task_runner_handle.h"
 #include "base/trace_event/trace_event.h"
 #include "ui/aura/window.h"
 #include "ui/aura/window_event_dispatcher.h"
 #include "ui/aura/window_tree_host.h"
 #include "ui/base/layout.h"
 #include "ui/display/display.h"
 #include "ui/display/display_finder.h"
 #include "ui/display/screen.h"
 #include "ui/display/util/display_util.h"
 #include "ui/display/util/x11/edid_parser_x11.h"
 #include "ui/events/platform/platform_event_source.h"
 #include "ui/events/platform/x11/x11_event_source.h"
 #include "ui/gfx/font_render_params.h"
 #include "ui/gfx/geometry/point_conversions.h"
 #include "ui/gfx/geometry/size_conversions.h"
 #include "ui/gfx/icc_profile.h"
 #include "ui/gfx/native_widget_types.h"
 #include "ui/gfx/x/x11_atom_cache.h"
 #include "ui/gfx/x/x11_types.h"
 #include "ui/views/linux_ui/linux_ui.h"
 #include "ui/views/widget/desktop_aura/desktop_screen.h"
 #include "ui/views/widget/desktop_aura/desktop_window_tree_host_x11.h"
 #include "ui/views/widget/desktop_aura/x11_topmost_window_finder.h"
 
 namespace {
 
-// The delay to perform configuration after RRNotify.  See the comment
-// in |Dispatch()|.
-const int64_t kConfigureDelayMs = 500;
-
 double GetDeviceScaleFactor() {
   float device_scale_factor = 1.0f;
   if (views::LinuxUI::instance()) {
     device_scale_factor =
       views::LinuxUI::instance()->GetDeviceScaleFactor();
   } else if (display::Display::HasForceDeviceScaleFactor()) {
     device_scale_factor = display::Display::GetForcedDeviceScaleFactor();
   }
   return device_scale_factor;
 }
@@ skipping 30 matching lines @@
 namespace views {
 
 ////////////////////////////////////////////////////////////////////////////////
 // DesktopScreenX11, public:
 
 DesktopScreenX11::DesktopScreenX11()
     : xdisplay_(gfx::GetXDisplay()),
       x_root_window_(DefaultRootWindow(xdisplay_)),
       has_xrandr_(false),
       xrandr_event_base_(0),
-      primary_display_index_(0) {
+      primary_display_index_(0),
+      weak_factory_(this) {
+  if (views::LinuxUI::instance())
+    views::LinuxUI::instance()->AddDeviceScaleFactorObserver(this);
   // We only support 1.3+. There were library changes before this and we should
   // use the new interface instead of the 1.2 one.
   int randr_version_major = 0;
   int randr_version_minor = 0;
   has_xrandr_ = XRRQueryVersion(
         xdisplay_, &randr_version_major, &randr_version_minor) &&
       randr_version_major == 1 &&
       randr_version_minor >= 3;
 
   if (has_xrandr_) {
     int error_base_ignored = 0;
     XRRQueryExtension(xdisplay_, &xrandr_event_base_, &error_base_ignored);
 
     if (ui::PlatformEventSource::GetInstance())
       ui::PlatformEventSource::GetInstance()->AddPlatformEventDispatcher(this);
     XRRSelectInput(xdisplay_,
                    x_root_window_,
                    RRScreenChangeNotifyMask |
                    RROutputChangeNotifyMask |
                    RRCrtcChangeNotifyMask);
 
     SetDisplaysInternal(BuildDisplaysFromXRandRInfo());
   } else {
     SetDisplaysInternal(GetFallbackDisplayList());
   }
 }
 
 DesktopScreenX11::~DesktopScreenX11() {
+  if (views::LinuxUI::instance())
+    views::LinuxUI::instance()->AddDeviceScaleFactorObserver(this);
   if (has_xrandr_ && ui::PlatformEventSource::GetInstance())
     ui::PlatformEventSource::GetInstance()->RemovePlatformEventDispatcher(this);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // DesktopScreenX11, display::Screen implementation:
 
 gfx::Point DesktopScreenX11::GetCursorScreenPoint() {
   TRACE_EVENT0("views", "DesktopScreenX11::GetCursorScreenPoint()");
 
@@ skipping 107 matching lines @@
           event->xproperty.atom == gfx::GetAtom("_NET_WORKAREA"));
 }
 
 uint32_t DesktopScreenX11::DispatchEvent(const ui::PlatformEvent& event) {
   if (event->type - xrandr_event_base_ == RRScreenChangeNotify) {
     // Pass the event through to xlib.
     XRRUpdateConfiguration(event);
   } else if (event->type - xrandr_event_base_ == RRNotify ||
              (event->type == PropertyNotify &&
               event->xproperty.atom == gfx::GetAtom("_NET_WORKAREA"))) {
-    // There's some sort of observer dispatch going on here, but I don't think
-    // it's the screen's?
-    if (configure_timer_.get() && configure_timer_->IsRunning()) {
-      configure_timer_->Reset();
-    } else {
-      configure_timer_.reset(new base::OneShotTimer());
-      configure_timer_->Start(
-          FROM_HERE,
-          base::TimeDelta::FromMilliseconds(kConfigureDelayMs),
-          this,
-          &DesktopScreenX11::ConfigureTimerFired);
-    }
+    RestartDelayedConfigurationTask();
   } else {
     NOTREACHED();
   }
 
   return ui::POST_DISPATCH_NONE;
 }
 
+void DesktopScreenX11::OnDeviceScaleFactorChanged() {
+  RestartDelayedConfigurationTask();
+}
+
 // static
 void DesktopScreenX11::UpdateDeviceScaleFactorForTest() {
   DesktopScreenX11* screen =
       static_cast<DesktopScreenX11*>(display::Screen::GetScreen());
-  screen->ConfigureTimerFired();
+  screen->UpdateDisplays();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // DesktopScreenX11, private:
 
 DesktopScreenX11::DesktopScreenX11(
     const std::vector<display::Display>& test_displays)
     : xdisplay_(gfx::GetXDisplay()),
       x_root_window_(DefaultRootWindow(xdisplay_)),
       has_xrandr_(false),
       xrandr_event_base_(0),
       displays_(test_displays),
-      primary_display_index_(0) {}
+      primary_display_index_(0),
+      weak_factory_(this) {
+  if (views::LinuxUI::instance())
+    views::LinuxUI::instance()->AddDeviceScaleFactorObserver(this);
+}
 
 std::vector<display::Display> DesktopScreenX11::BuildDisplaysFromXRandRInfo() {
   std::vector<display::Display> displays;
   gfx::XScopedPtr<
       XRRScreenResources,
       gfx::XObjectDeleter<XRRScreenResources, void, XRRFreeScreenResources>>
       resources(XRRGetScreenResourcesCurrent(xdisplay_, x_root_window_));
   if (!resources) {
     LOG(ERROR) << "XRandR returned no displays. Falling back to Root Window.";
     return GetFallbackDisplayList();
@@ skipping 86 matching lines @@
       displays.push_back(display);
     }
   }
 
   if (displays.empty())
     return GetFallbackDisplayList();
 
   return displays;
 }
 
-void DesktopScreenX11::ConfigureTimerFired() {
+void DesktopScreenX11::RestartDelayedConfigurationTask() {
+  delayed_configuration_task_.Reset(base::Bind(
+      &DesktopScreenX11::UpdateDisplays, weak_factory_.GetWeakPtr()));
+  base::ThreadTaskRunnerHandle::Get()->PostTask(
+      FROM_HERE, delayed_configuration_task_.callback());
+}
+
+void DesktopScreenX11::UpdateDisplays() {
   std::vector<display::Display> old_displays = displays_;
   SetDisplaysInternal(BuildDisplaysFromXRandRInfo());
   change_notifier_.NotifyDisplaysChanged(old_displays, displays_);
 }
 
 void DesktopScreenX11::SetDisplaysInternal(
     const std::vector<display::Display>& displays) {
   displays_ = displays;
   gfx::SetFontRenderParamsDeviceScaleFactor(
       GetPrimaryDisplay().device_scale_factor());
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 
 display::Screen* CreateDesktopScreen() {
   return new DesktopScreenX11;
 }
 
 }  // namespace views