exo: Select cursor capture scale at run time

components/exo/pointer.cc

 // Copyright 2015 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 "components/exo/pointer.h"
 
+#include <algorithm>

[reveman, 2017/06/22 21:24:01]

nit: remove if not needed

[Dominik Laskowski, 2017/06/22 22:31:14]

Removed along with std::max.

 #include <utility>
 
 #include "ash/public/cpp/shell_window_ids.h"
 #include "cc/output/copy_output_request.h"
 #include "cc/output/copy_output_result.h"
 #include "components/exo/pointer_delegate.h"
 #include "components/exo/pointer_stylus_delegate.h"
 #include "components/exo/surface.h"
 #include "components/exo/wm_helper.h"
 #include "ui/aura/client/cursor_client.h"
@@ skipping 17 matching lines @@
 
 namespace exo {
 namespace {
 
 // TODO(oshima): Some accessibility features, including large cursors, disable
 // hardware cursors. Ash does not support compositing for custom cursors, so it
 // replaces them with the default cursor. As a result, this scale has no effect
 // for now. See crbug.com/708378.
 const float kLargeCursorScale = 2.8f;
 
-// Scale at which cursor snapshot is captured. The resulting bitmap is scaled on
-// displays whose DSF does not match this scale.
-const float kCursorCaptureScale = 2.0f;
-
 const double kLocatedEventEpsilonSquared = 1.0 / (2000.0 * 2000.0);
 
 // Synthesized events typically lack floating point precision so to avoid
 // generating mouse event jitter we consider the location of these events
 // to be the same as |location| if floored values match.
 bool SameLocation(const ui::LocatedEvent* event, const gfx::PointF& location) {
   if (event->flags() & ui::EF_IS_SYNTHESIZED)
     return event->location() == gfx::ToFlooredPoint(location);
 
   // In general, it is good practice to compare floats using an epsilon.
@@ skipping 14 matching lines @@
 
 Pointer::Pointer(PointerDelegate* delegate)
     : delegate_(delegate),
       cursor_(ui::CursorType::kNull),
       cursor_capture_source_id_(base::UnguessableToken::Create()),
       cursor_capture_weak_ptr_factory_(this) {
   auto* helper = WMHelper::GetInstance();
   helper->AddPreTargetHandler(this);
   helper->AddCursorObserver(this);
   helper->AddDisplayConfigurationObserver(this);
+
+  OnDisplayConfigurationChanged();

[reveman, 2017/06/22 21:24:01]

nit: don't call this here. see comment below

[Dominik Laskowski, 2017/06/22 22:31:14]

Done.

 }
 
 Pointer::~Pointer() {
   delegate_->OnPointerDestroying(this);
   if (surface_)
     surface_->RemoveSurfaceObserver(this);
   if (focus_) {
     focus_->RemoveSurfaceObserver(this);
     focus_->UnregisterCursorProvider(this);
   }
@@ skipping 171 matching lines @@
 void Pointer::OnCursorDisplayChanged(const display::Display& display) {
   if (focus_)
     UpdateCursor();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // WMHelper::DisplayConfigurationObserver overrides:
 
 void Pointer::OnDisplayConfigurationChanged() {
   UpdatePointerSurface(surface_);
+
+  capture_scale_ = 1.0f;
+  for (const auto& display : display::Screen::GetScreen()->GetAllDisplays()) {
+    const auto& info = WMHelper::GetInstance()->GetDisplayInfo(display.id());
+    capture_scale_ = std::max(capture_scale_, info.device_scale_factor());
+  }

[reveman, 2017/06/22 21:24:01]

nit: please move this logic into a GetCaptureScale() helper function in
anonymous namespace so you can do capture_scale_(GetCaptureScale()) in ctor
initialization list instead of calling OnDisplayConfigurationChanged from there

[Dominik Laskowski, 2017/06/22 22:31:14]

Done.

 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // SurfaceDelegate overrides:
 
 void Pointer::OnSurfaceCommit() {
   surface_->CheckIfSurfaceHierarchyNeedsCommitToNewSurfaces();
   surface_->CommitSurfaceHierarchy();
 
   // Capture new cursor to reflect result of commit.
@@ skipping 55 matching lines @@
   DCHECK(surface_);
   DCHECK(focus_);
 
   // Surface size is in DIPs, while layer size is in pseudo-DIP units that
   // depend on the DSF of the display mode. Scale the layer to capture the
   // surface at a constant pixel size, regardless of the primary display's
   // UI scale and display mode DSF.
   display::Display display = display::Screen::GetScreen()->GetPrimaryDisplay();
   auto* helper = WMHelper::GetInstance();
   float scale = helper->GetDisplayInfo(display.id()).GetEffectiveUIScale() *
-                kCursorCaptureScale / display.device_scale_factor();
+                capture_scale_ / display.device_scale_factor();
   surface_->window()->SetTransform(gfx::GetScaleTransform(gfx::Point(), scale));
 
   std::unique_ptr<cc::CopyOutputRequest> request =
       cc::CopyOutputRequest::CreateBitmapRequest(
           base::Bind(&Pointer::OnCursorCaptured,
                      cursor_capture_weak_ptr_factory_.GetWeakPtr(), hotspot));
 
   request->set_source(cursor_capture_source_id_);
   surface_->window()->layer()->RequestCopyOfOutput(std::move(request));
 }
@@ skipping 14 matching lines @@
   UpdateCursor();
 }
 
 void Pointer::UpdateCursor() {
   DCHECK(focus_);
 
   if (cursor_bitmap_.drawsNothing()) {
     cursor_ = ui::CursorType::kNone;
   } else {
     SkBitmap bitmap = cursor_bitmap_;
-    gfx::Point hotspot =
-        gfx::ScaleToFlooredPoint(hotspot_, kCursorCaptureScale);
+    gfx::Point hotspot = gfx::ScaleToFlooredPoint(hotspot_, capture_scale_);
 
     auto* helper = WMHelper::GetInstance();
     const display::Display& display = helper->GetCursorDisplay();
     float scale = helper->GetDisplayInfo(display.id()).device_scale_factor() /
-                  kCursorCaptureScale;
+                  capture_scale_;
 
     if (helper->GetCursorSet() == ui::CURSOR_SET_LARGE)
       scale *= kLargeCursorScale;
 
     ui::ScaleAndRotateCursorBitmapAndHotpoint(scale, display.rotation(),
                                               &bitmap, &hotspot);
 
     ui::PlatformCursor platform_cursor;
 #if defined(USE_OZONE)
     // TODO(reveman): Add interface for creating cursors from GpuMemoryBuffers
@@ skipping 17 matching lines @@
   if (!root_window)
     return;
 
   aura::client::CursorClient* cursor_client =
       aura::client::GetCursorClient(root_window);
   if (cursor_client)
     cursor_client->SetCursor(cursor_);
 }
 
 }  // namespace exo