Properly scale the coordinate for TouchSelection when use-zoom-for-dsf mode is on.

cc/trees/layer_tree_host_impl_unittest.cc

 // Copyright 2011 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 "cc/trees/layer_tree_host_impl.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 #include <cmath>
@@ skipping 7950 matching lines @@
   host_impl_->DidDrawAllLayers(frame);
   EXPECT_TRUE(host_impl_->SwapBuffers(frame));
 
   const std::vector<ui::LatencyInfo>& metadata_latency_after =
       fake_output_surface->last_sent_frame().metadata.latency_info;
   EXPECT_EQ(1u, metadata_latency_after.size());
   EXPECT_TRUE(metadata_latency_after[0].FindLatency(
       ui::INPUT_EVENT_LATENCY_BEGIN_RWH_COMPONENT, 0, NULL));
 }
 
-TEST_F(LayerTreeHostImplTest, SelectionBoundsPassedToCompositorFrameMetadata) {
+class LayerTreeHostImplTestWithPaintedDeviceScaleFactor
+    : public LayerTreeHostImplTest,
+      public testing::WithParamInterface<float> {
+ public:
+  LayerTreeHostImplTestWithPaintedDeviceScaleFactor() = default;
+  ~LayerTreeHostImplTestWithPaintedDeviceScaleFactor() override = default;
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(LayerTreeHostImplTestWithPaintedDeviceScaleFactor);
+};
+
+TEST_P(LayerTreeHostImplTestWithPaintedDeviceScaleFactor,
+       SelectionBoundsPassedToCompositorFrameMetadata) {
+  float painted_device_scale = GetParam();
+  host_impl_->active_tree()->set_painted_device_scale_factor(
+      painted_device_scale);
+
   int root_layer_id = 1;
   scoped_ptr<SolidColorLayerImpl> root =
       SolidColorLayerImpl::Create(host_impl_->active_tree(), root_layer_id);
   root->SetPosition(gfx::PointF());
   root->SetBounds(gfx::Size(10, 10));
   root->SetDrawsContent(true);
   root->SetForceRenderSurface(true);
 
   host_impl_->active_tree()->SetRootLayer(std::move(root));
 
@@ skipping 24 matching lines @@
   EXPECT_EQ(DRAW_SUCCESS, PrepareToDrawFrame(&frame));
   host_impl_->DrawLayers(&frame);
   host_impl_->DidDrawAllLayers(frame);
   EXPECT_TRUE(host_impl_->SwapBuffers(frame));
 
   // Ensure the selection bounds have propagated to the frame metadata.
   const ViewportSelection& selection_after =
       fake_output_surface->last_sent_frame().metadata.selection;
   EXPECT_EQ(selection.start.type, selection_after.start.type);
   EXPECT_EQ(selection.end.type, selection_after.end.type);
-  EXPECT_EQ(gfx::PointF(selection_bottom), selection_after.start.edge_bottom);
-  EXPECT_EQ(gfx::PointF(selection_top), selection_after.start.edge_top);
+  EXPECT_EQ(gfx::ScalePoint(gfx::PointF(selection_bottom),

[danakj, 2016/02/25 19:37:22]

Does this all mean that there is some input to the compositor that isn't being
scaled by the painted device scale factor?

I'm not expecting cc to have to use the painted DSF for anything other than
passing it along. So I'd expect all inputs to already be scaled.

[oshima, 2016/02/25 21:52:03]

This is an output from compositor. Currently, cc/ is responsible for computing
the selection bounds, which is attached to the frame metadata, which in turn, is
consumed by browser process in DIP.  See ComputeViewportSelectionBound (It
converts from layer -> screen -> dip).

Other selection code lives in content/renderer so it's not clear to me why this
is in cc/ though.

While it's technically possible to move the conversion to browser process, but
I'd like to avoid it because browser currently expects to receive DIP from
renderer process.

+                            1.f / painted_device_scale),
+            selection_after.start.edge_bottom);
+  EXPECT_EQ(
+      gfx::ScalePoint(gfx::PointF(selection_top), 1.f / painted_device_scale),
+      selection_after.start.edge_top);
   EXPECT_TRUE(selection_after.start.visible);
   EXPECT_TRUE(selection_after.start.visible);
 }
 
+INSTANTIATE_TEST_CASE_P(WithPaintedDeviceScaleFactor,
+                        LayerTreeHostImplTestWithPaintedDeviceScaleFactor,
+                        testing::Values(1.0f, 1.5f, 2.0f));
+
 class SimpleSwapPromiseMonitor : public SwapPromiseMonitor {
  public:
   SimpleSwapPromiseMonitor(LayerTreeHost* layer_tree_host,
                            LayerTreeHostImpl* layer_tree_host_impl,
                            int* set_needs_commit_count,
                            int* set_needs_redraw_count,
                            int* forward_to_main_count)
       : SwapPromiseMonitor(layer_tree_host, layer_tree_host_impl),
         set_needs_commit_count_(set_needs_commit_count),
         set_needs_redraw_count_(set_needs_redraw_count),
@@ skipping 2101 matching lines @@
     // There should not be any jitter measured till we hit the fixed point hits
     // threshold.
     float expected_jitter =
         (i == pending_tree->kFixedPointHitsThreshold) ? 500 : 0;
     EXPECT_EQ(jitter, expected_jitter);
   }
 }
 
 }  // namespace
 }  // namespace cc