Plumb selection edge points through the compositor

cc/trees/layer_tree_impl_unittest.cc

 // Copyright 2014 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_impl.h"
 
 #include "cc/layers/heads_up_display_layer_impl.h"
 #include "cc/layers/layer.h"
 #include "cc/test/fake_impl_proxy.h"
 #include "cc/test/fake_layer_tree_host_impl.h"
@@ skipping 2080 matching lines @@
   host_impl().SetViewportSize(root->bounds());
   host_impl().active_tree()->SetRootLayer(root.Pass());
   host_impl().UpdateNumChildrenAndDrawPropertiesForActiveTree();
 
   // Sanity check the scenario we just created.
   ASSERT_EQ(1u, RenderSurfaceLayerList().size());
   ASSERT_EQ(1u, root_layer()->render_surface()->layer_list().size());
 
   LayerSelectionBound left_input;
   left_input.type = SELECTION_BOUND_LEFT;
-  left_input.layer_rect = gfx::RectF(10, 10, 5, 20);
+  left_input.edge_top = gfx::PointF(10, 10);
+  left_input.edge_bottom = gfx::PointF(10, 20);
   left_input.layer_id = root_layer_id;
 
   LayerSelectionBound right_input;
   right_input.type = SELECTION_BOUND_RIGHT;
-  right_input.layer_rect = gfx::RectF(50, 10, 5, 20);
+  right_input.edge_top = gfx::PointF(50, 10);
+  right_input.edge_bottom = gfx::PointF(50, 30);
   right_input.layer_id = root_layer_id;
 
   ViewportSelectionBound left_output, right_output;
 
   // Empty input bounds should produce empty output bounds.
   host_impl().active_tree()->GetViewportSelection(&left_output, &right_output);
   EXPECT_EQ(ViewportSelectionBound(), left_output);
   EXPECT_EQ(ViewportSelectionBound(), right_output);
 
   // Selection bounds should produce distinct left and right bounds.
   host_impl().active_tree()->RegisterSelection(left_input, right_input);
   host_impl().active_tree()->GetViewportSelection(&left_output, &right_output);
   EXPECT_EQ(left_input.type, left_output.type);
-  EXPECT_EQ(left_input.layer_rect, left_output.viewport_rect);
+  EXPECT_EQ(left_input.edge_bottom, left_output.edge_bottom);
+  EXPECT_EQ(left_input.edge_top, left_output.edge_top);
   EXPECT_TRUE(left_output.visible);
   EXPECT_EQ(right_input.type, right_output.type);
-  EXPECT_EQ(right_input.layer_rect, right_output.viewport_rect);
+  EXPECT_EQ(right_input.edge_bottom, right_output.edge_bottom);
+  EXPECT_EQ(right_input.edge_top, right_output.edge_top);
   EXPECT_TRUE(right_output.visible);
 
   // Insertion bounds should produce identical left and right bounds.
   LayerSelectionBound insertion_input;
   insertion_input.type = SELECTION_BOUND_CENTER;
-  insertion_input.layer_rect = gfx::RectF(10, 10, 5, 20);
+  insertion_input.edge_top = gfx::PointF(15, 10);
+  insertion_input.edge_bottom = gfx::PointF(15, 30);
   insertion_input.layer_id = root_layer_id;
   host_impl().active_tree()->RegisterSelection(insertion_input,
                                                LayerSelectionBound());
   host_impl().active_tree()->GetViewportSelection(&left_output, &right_output);
   EXPECT_EQ(insertion_input.type, left_output.type);
-  EXPECT_EQ(insertion_input.layer_rect, left_output.viewport_rect);
+  EXPECT_EQ(insertion_input.edge_bottom, left_output.edge_bottom);
+  EXPECT_EQ(insertion_input.edge_top, left_output.edge_top);
   EXPECT_TRUE(left_output.visible);
   EXPECT_EQ(left_output, right_output);
 }
 
 TEST_F(LayerTreeImplTest, SelectionBoundsForPartialOccludedLayers) {
   int root_layer_id = 12345;
   int clip_layer_id = 1234;
   int clipped_layer_id = 123;
   scoped_ptr<LayerImpl> root =
       LayerImpl::Create(host_impl().active_tree(), root_layer_id);
@@ skipping 45 matching lines @@
 
   host_impl().SetViewportSize(root->bounds());
   host_impl().active_tree()->SetRootLayer(root.Pass());
   host_impl().UpdateNumChildrenAndDrawPropertiesForActiveTree();
 
   // Sanity check the scenario we just created.
   ASSERT_EQ(1u, RenderSurfaceLayerList().size());
 
   LayerSelectionBound left_input;
   left_input.type = SELECTION_BOUND_LEFT;
-  left_input.layer_rect = gfx::RectF(25, 10, 5, 20);
+  left_input.edge_top = gfx::PointF(25, 10);
+  left_input.edge_bottom = gfx::PointF(25, 30);
   left_input.layer_id = clipped_layer_id;
 
   LayerSelectionBound right_input;
   right_input.type = SELECTION_BOUND_RIGHT;
-  right_input.layer_rect = gfx::RectF(75, 10, 5, 20);
+  right_input.edge_top = gfx::PointF(75, 10);
+  right_input.edge_bottom = gfx::PointF(75, 30);
   right_input.layer_id = clipped_layer_id;
   host_impl().active_tree()->RegisterSelection(left_input, right_input);
 
   // The left bound should be occluded by the clip layer.
   ViewportSelectionBound left_output, right_output;
   host_impl().active_tree()->GetViewportSelection(&left_output, &right_output);
   EXPECT_EQ(left_input.type, left_output.type);
-  gfx::RectF expected_left_output_rect = left_input.layer_rect;
-  expected_left_output_rect.Offset(clipping_offset);
-  EXPECT_EQ(expected_left_output_rect, left_output.viewport_rect);
+  gfx::PointF expected_left_output_top = left_input.edge_top;
+  gfx::PointF expected_left_output_bottom = left_input.edge_bottom;
+  expected_left_output_top.Offset(clipping_offset.x(), clipping_offset.y());
+  expected_left_output_bottom.Offset(clipping_offset.x(), clipping_offset.y());
+  EXPECT_EQ(expected_left_output_top, left_output.edge_top);
+  EXPECT_EQ(expected_left_output_bottom, left_output.edge_bottom);
   EXPECT_TRUE(left_output.visible);
   EXPECT_EQ(right_input.type, right_output.type);
-  gfx::RectF expected_right_output_rect = right_input.layer_rect;
-  expected_right_output_rect.Offset(clipping_offset);
-  EXPECT_EQ(expected_right_output_rect, right_output.viewport_rect);
+  gfx::PointF expected_right_output_top = right_input.edge_top;
+  gfx::PointF expected_right_output_bottom = right_input.edge_bottom;
+  expected_right_output_bottom.Offset(clipping_offset.x(), clipping_offset.y());
+  expected_right_output_top.Offset(clipping_offset.x(), clipping_offset.y());
+  EXPECT_EQ(expected_right_output_top, right_output.edge_top);
+  EXPECT_EQ(expected_right_output_bottom, right_output.edge_bottom);
   EXPECT_FALSE(right_output.visible);
 
   // Handles outside the viewport bounds should be marked invisible.
-  left_input.layer_rect = gfx::RectF(-25, 0, 5, 20);
+  left_input.edge_top = gfx::PointF(-25, 0);
+  left_input.edge_bottom = gfx::PointF(-25, 20);
   host_impl().active_tree()->RegisterSelection(left_input, right_input);
   host_impl().active_tree()->GetViewportSelection(&left_output, &right_output);
   EXPECT_FALSE(left_output.visible);
 
-  left_input.layer_rect = gfx::RectF(0, -25, 5, 20);
+  left_input.edge_top = gfx::PointF(0, -25);
+  left_input.edge_bottom = gfx::PointF(0, -5);
   host_impl().active_tree()->RegisterSelection(left_input, right_input);
   host_impl().active_tree()->GetViewportSelection(&left_output, &right_output);
   EXPECT_FALSE(left_output.visible);
 
   // If the handle bottom is partially visible, the handle is marked visible.
-  left_input.layer_rect = gfx::RectF(0, -20, 5, 21);
+  left_input.edge_top = gfx::PointF(0, -20);
+  left_input.edge_bottom = gfx::PointF(0, 1);
   host_impl().active_tree()->RegisterSelection(left_input, right_input);
   host_impl().active_tree()->GetViewportSelection(&left_output, &right_output);
   EXPECT_TRUE(left_output.visible);
 }
 
 TEST_F(LayerTreeImplTest, SelectionBoundsForScaledLayers) {
   int root_layer_id = 1;
   int sub_layer_id = 2;
   scoped_ptr<LayerImpl> root =
       LayerImpl::Create(host_impl().active_tree(), root_layer_id);
@@ skipping 39 matching lines @@
       page_scale_factor, page_scale_factor, page_scale_factor);
   host_impl().active_tree()->SetRootLayer(root.Pass());
   host_impl().active_tree()->SetViewportLayersFromIds(1, 1, Layer::INVALID_ID);
   host_impl().UpdateNumChildrenAndDrawPropertiesForActiveTree();
 
   // Sanity check the scenario we just created.
   ASSERT_EQ(1u, RenderSurfaceLayerList().size());
 
   LayerSelectionBound left_input;
   left_input.type = SELECTION_BOUND_LEFT;
-  left_input.layer_rect = gfx::RectF(10, 10, 5, 20);
+  left_input.edge_top = gfx::PointF(10, 10);
+  left_input.edge_bottom = gfx::PointF(10, 30);
   left_input.layer_id = root_layer_id;
 
   LayerSelectionBound right_input;
   right_input.type = SELECTION_BOUND_RIGHT;
-  right_input.layer_rect = gfx::RectF(0, 0, 5, 20);
+  right_input.edge_top = gfx::PointF(0, 0);
+  right_input.edge_bottom = gfx::PointF(0, 20);
   right_input.layer_id = sub_layer_id;
   host_impl().active_tree()->RegisterSelection(left_input, right_input);
 
   // The viewport bounds should be properly scaled by the page scale, but should
   // remain in DIP coordinates.
   ViewportSelectionBound left_output, right_output;
   host_impl().active_tree()->GetViewportSelection(&left_output, &right_output);
   EXPECT_EQ(left_input.type, left_output.type);
-  gfx::RectF expected_left_output_rect = left_input.layer_rect;
-  expected_left_output_rect.Scale(page_scale_factor);
-  EXPECT_EQ(left_input.layer_rect, left_output.viewport_rect);
+  gfx::PointF expected_left_output_top = left_input.edge_top;
+  gfx::PointF expected_left_output_bottom = left_input.edge_bottom;
+  expected_left_output_top.Scale(page_scale_factor);
+  expected_left_output_bottom.Scale(page_scale_factor);
+  EXPECT_EQ(left_input.edge_top, left_output.edge_top);
+  EXPECT_EQ(left_input.edge_bottom, left_output.edge_bottom);
   EXPECT_TRUE(left_output.visible);
   EXPECT_EQ(right_input.type, right_output.type);
-  gfx::RectF expected_right_output_rect = right_input.layer_rect;
-  expected_right_output_rect.Offset(sub_layer_offset);
-  expected_right_output_rect.Scale(page_scale_factor);
-  EXPECT_EQ(expected_right_output_rect, right_output.viewport_rect);
+
+  gfx::PointF expected_right_output_top = right_input.edge_top;
+  gfx::PointF expected_right_output_bottom = right_input.edge_bottom;
+  expected_right_output_top.Offset(sub_layer_offset.x(), sub_layer_offset.y());
+  expected_right_output_bottom.Offset(sub_layer_offset.x(),
+                                      sub_layer_offset.y());
+  expected_right_output_top.Scale(page_scale_factor);
+  expected_right_output_bottom.Scale(page_scale_factor);
+  EXPECT_EQ(expected_right_output_top, right_output.edge_top);
+  EXPECT_EQ(expected_right_output_bottom, right_output.edge_bottom);
   EXPECT_TRUE(right_output.visible);
 }
 
 TEST_F(LayerTreeImplTest, NumLayersTestOne) {
   EXPECT_EQ(0u, host_impl().active_tree()->NumLayers());
   scoped_ptr<LayerImpl> root = LayerImpl::Create(host_impl().active_tree(), 1);
   EXPECT_EQ(1u, host_impl().active_tree()->NumLayers());
 }
 
 TEST_F(LayerTreeImplTest, NumLayersSmallTree) {
   EXPECT_EQ(0u, host_impl().active_tree()->NumLayers());
   scoped_ptr<LayerImpl> root = LayerImpl::Create(host_impl().active_tree(), 1);
   root->AddChild(LayerImpl::Create(host_impl().active_tree(), 2));
   root->AddChild(LayerImpl::Create(host_impl().active_tree(), 3));
   root->child_at(1)->AddChild(LayerImpl::Create(host_impl().active_tree(), 4));
   EXPECT_EQ(4u, host_impl().active_tree()->NumLayers());
 }
 
 }  // namespace
 }  // namespace cc