linux_aura: Enable HIDPI support

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/x11/edid_parser_x11.h"
 #include "ui/aura/root_window.h"
 #include "ui/aura/root_window_host.h"
+#include "ui/base/layout.h"
 #include "ui/base/x/x11_util.h"
 #include "ui/gfx/display.h"
 #include "ui/gfx/display_observer.h"
 #include "ui/gfx/native_widget_types.h"
 #include "ui/gfx/screen.h"
 #include "ui/gfx/x/x11_types.h"
 #include "ui/views/widget/desktop_aura/desktop_root_window_host_x11.h"
 #include "ui/views/widget/desktop_aura/desktop_screen.h"
 
 namespace {
 
 // The delay to perform configuration after RRNotify.  See the comment
 // in |Dispatch()|.
 const int64 kConfigureDelayMs = 500;
 
+float g_device_scale_factor = 1.0f;

[Daniel Erat, 2013/10/29 14:28:25]

why does this need to be global? it looks like it gets assigned by
GetFallbackDisplayList() (which is called by BuildDisplaysFromXRandRInfo() if
the XRandR call fails) and later by BuildDisplaysFromXRandRInfo() if the first
display isn't blacklisted, but i don't see where it's being read.

[Mikhail, 2013/10/29 14:50:55]

Indeed! Thanks for noticing it!

+
+float GetDeviceScaleFactor(int screen_dim, int mm_screen_dim) {

[Daniel Erat, 2013/10/29 14:28:25]

what does "dim" stand for here?

[Mikhail, 2013/10/29 14:50:55]

dimention, probably I should put the whole word.

+  const int kCSSDefaultDIPCountPerInch = 96;

[Daniel Erat, 2013/10/29 14:28:25]

where does this number come from?

[Mikhail, 2013/10/29 14:50:55]

We always assume 96 CSS pixels in an inch

+  const float kInchInMm = 25.4f;
+
+  float screen_DPI = (screen_dim * kInchInMm) / mm_screen_dim;

[Daniel Erat, 2013/10/29 14:28:25]

nit: screen_dpi

+  float scale = screen_DPI / kCSSDefaultDIPCountPerInch;
+
+  return ui::GetImageScale(ui::GetSupportedScaleFactor(scale));
+}
+
 std::vector<gfx::Display> GetFallbackDisplayList() {
   ::XDisplay* display = gfx::GetXDisplay();
   ::Screen* screen = DefaultScreenOfDisplay(display);
   int width = WidthOfScreen(screen);
   int height = HeightOfScreen(screen);
+  int mm_width = WidthMMOfScreen(screen);
+  int mm_height = HeightMMOfScreen(screen);
 
-  return std::vector<gfx::Display>(
-      1, gfx::Display(0, gfx::Rect(0, 0, width, height)));
+  gfx::Rect bounds_in_pixels(0, 0, width, height);
+  gfx::Display gfx_display(0, bounds_in_pixels);
+  if (!gfx::Display::HasForceDeviceScaleFactor() &&
+      !ui::IsXDisplaySizeBlackListed(mm_width, mm_height)) {
+    g_device_scale_factor = GetDeviceScaleFactor(width, mm_width);
+    DCHECK_LE(1.0f, g_device_scale_factor);
+    gfx_display.SetScaleAndBounds(g_device_scale_factor, bounds_in_pixels);
+  }
+
+  return std::vector<gfx::Display>(1, gfx_display);
 }
 
 }  // namespace
 
 namespace views {
 
 ////////////////////////////////////////////////////////////////////////////////
 // DesktopScreenX11, public:
 
 DesktopScreenX11::DesktopScreenX11()
@@ skipping 71 matching lines @@
     }
   }
 
   displays_ = incoming;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // DesktopScreenX11, gfx::Screen implementation:
 
 bool DesktopScreenX11::IsDIPEnabled() {
-  return false;
+  return true;
 }
 
 gfx::Point DesktopScreenX11::GetCursorScreenPoint() {
   XDisplay* display = gfx::GetXDisplay();
 
   ::Window root, child;
   int root_x, root_y, win_x, win_y;
   unsigned int mask;
   XQueryPointer(display,
                 DefaultRootWindow(display),
@@ skipping 168 matching lines @@
 
       int64 display_id = -1;
       if (!base::GetDisplayId(output_id, i, &display_id)) {
         // It isn't ideal, but if we can't parse the EDID data, fallback on the
         // display number.
         display_id = i;
       }
 
       gfx::Rect crtc_bounds(crtc->x, crtc->y, crtc->width, crtc->height);
       gfx::Display display(display_id, crtc_bounds);
+
+      if (!gfx::Display::HasForceDeviceScaleFactor()) {
+        if (i == 0 && !ui::IsXDisplaySizeBlackListed(output_info->mm_width,
+                                                     output_info->mm_height)) {
+          // As per display scale factor is not supported right now,
+          // the primary display's scale factor is always used.
+          g_device_scale_factor = GetDeviceScaleFactor(crtc->width,
+                                                       output_info->mm_width);
+        }
+        DCHECK_LE(1.0f, g_device_scale_factor);
+        display.SetScaleAndBounds(g_device_scale_factor, crtc_bounds);
+      }
+
       if (has_work_area) {
         gfx::Rect intersection = crtc_bounds;
         intersection.Intersect(work_area);
         display.set_work_area(intersection);
       }
 
       displays.push_back(display);
 
       XRRFreeCrtcInfo(crtc);
     }
@@ skipping 14 matching lines @@
   ProcessDisplayChange(new_displays);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 
 gfx::Screen* CreateDesktopScreen() {
   return new DesktopScreenX11;
 }
 
 }  // namespace views