Route selection bounds updates through the compositor

cc/trees/layer_tree_impl.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_impl.h"
 
 #include <limits>
 #include <set>
 
 #include "base/debug/trace_event.h"
@@ skipping 103 matching lines @@
     outer_viewport_scroll_layer_->SetScrollOffsetDelegate(NULL);
   inner_viewport_scroll_delegate_proxy_.reset();
   outer_viewport_scroll_delegate_proxy_.reset();
 
   root_layer_ = layer.Pass();
   currently_scrolling_layer_ = NULL;
   inner_viewport_scroll_layer_ = NULL;
   outer_viewport_scroll_layer_ = NULL;
   page_scale_layer_ = NULL;
 
+  ClearSelection();

[aelias_OOO_until_Jul13, 2014/06/28 00:02:17]

I suggest removing this call.  We may eventually want to do something like
detach and reattach the same layer tree, this would throw out information
unnecessarily.

[jdduke (slow), 2014/06/28 00:29:10]

Done.

+
   layer_tree_host_impl_->OnCanDrawStateChangedForTree();
 }
 
 LayerImpl* LayerTreeImpl::InnerViewportScrollLayer() const {
   return inner_viewport_scroll_layer_;
 }
 
 LayerImpl* LayerTreeImpl::OuterViewportScrollLayer() const {
   return outer_viewport_scroll_layer_;
 }
@@ skipping 39 matching lines @@
     inner_viewport_scroll_layer_->SetScrollOffsetDelegate(NULL);
   if (outer_viewport_scroll_layer_)
     outer_viewport_scroll_layer_->SetScrollOffsetDelegate(NULL);
   inner_viewport_scroll_delegate_proxy_.reset();
   outer_viewport_scroll_delegate_proxy_.reset();
   inner_viewport_scroll_layer_ = NULL;
   outer_viewport_scroll_layer_ = NULL;
   page_scale_layer_ = NULL;
   currently_scrolling_layer_ = NULL;
 
+  ClearSelection();

[aelias_OOO_until_Jul13, 2014/06/28 00:02:17]

Likewise, please remove this call.

[jdduke (slow), 2014/06/28 00:29:10]

Done.

+
   render_surface_layer_list_.clear();
   set_needs_update_draw_properties();
   return root_layer_.Pass();
 }
 
 void LayerTreeImpl::PushPropertiesTo(LayerTreeImpl* target_tree) {
   // The request queue should have been processed and does not require a push.
   DCHECK_EQ(ui_resource_request_queue_.size(), 0u);
 
   if (next_activation_forces_redraw_) {
@@ skipping 10 matching lines @@
 
   if (page_scale_layer_ && inner_viewport_scroll_layer_) {
     target_tree->SetViewportLayersFromIds(
         page_scale_layer_->id(),
         inner_viewport_scroll_layer_->id(),
         outer_viewport_scroll_layer_ ? outer_viewport_scroll_layer_->id()
                                      : Layer::INVALID_ID);
   } else {
     target_tree->ClearViewportLayers();
   }
+
+  target_tree->RegisterSelection(selection_anchor_, selection_focus_);
+
   // This should match the property synchronization in
   // LayerTreeHost::finishCommitOnImplThread().
   target_tree->set_source_frame_number(source_frame_number());
   target_tree->set_background_color(background_color());
   target_tree->set_has_transparent_background(has_transparent_background());
 
   if (ContentsTexturesPurged())
     target_tree->SetContentsTexturesPurged();
   else
     target_tree->ResetContentsTexturesPurged();
@@ skipping 814 matching lines @@
   DCHECK(current);
   current->ReleaseResources();
   if (current->mask_layer())
     ReleaseResourcesRecursive(current->mask_layer());
   if (current->replica_layer())
     ReleaseResourcesRecursive(current->replica_layer());
   for (size_t i = 0; i < current->children().size(); ++i)
     ReleaseResourcesRecursive(current->children()[i]);
 }
 
+void LayerTreeImpl::ClearSelection() {
+  RegisterSelection(LayerSelectionBound(), LayerSelectionBound());
+}
+
 template <typename LayerType>
 static inline bool LayerClipsSubtree(LayerType* layer) {
   return layer->masks_to_bounds() || layer->mask_layer();
 }
 
 static bool PointHitsRect(
     const gfx::PointF& screen_space_point,
     const gfx::Transform& local_space_to_screen_space_transform,
     const gfx::RectF& local_space_rect,
     float* distance_to_camera) {
@@ skipping 58 matching lines @@
 
   // If ProjectPoint could not project to a valid value, then we assume that
   // this point doesn't hit this region.
   if (clipped)
     return false;
 
   return layer_space_region.Contains(
       gfx::ToRoundedPoint(hit_test_point_in_layer_space));
 }
 
-static LayerImpl* GetNextClippingLayer(LayerImpl* layer) {
+static const LayerImpl* GetNextClippingLayer(const LayerImpl* layer) {
   if (layer->scroll_parent())
     return layer->scroll_parent();
   if (layer->clip_parent())
     return layer->clip_parent();
   return layer->parent();
 }
 
 static bool PointIsClippedBySurfaceOrClipRect(
     const gfx::PointF& screen_space_point,
-    LayerImpl* layer) {
+    const LayerImpl* layer) {
   // Walk up the layer tree and hit-test any render_surfaces and any layer
   // clip rects that are active.
   for (; layer; layer = GetNextClippingLayer(layer)) {
     if (layer->render_surface() &&
         !PointHitsRect(screen_space_point,
                        layer->render_surface()->screen_space_transform(),
                        layer->render_surface()->content_rect(),
                        NULL))
       return true;
 
     if (LayerClipsSubtree(layer) &&
         !PointHitsRect(screen_space_point,
                        layer->screen_space_transform(),
                        gfx::Rect(layer->content_bounds()),
                        NULL))
       return true;
   }
 
   // If we have finished walking all ancestors without having already exited,
   // then the point is not clipped by any ancestors.
   return false;
 }
 
-static bool PointHitsLayer(LayerImpl* layer,
+static bool PointHitsLayer(const LayerImpl* layer,
                            const gfx::PointF& screen_space_point,
                            float* distance_to_intersection) {
   gfx::RectF content_rect(layer->content_bounds());
   if (!PointHitsRect(screen_space_point,
                      layer->screen_space_transform(),
                      content_rect,
                      distance_to_intersection))
     return false;
 
   // At this point, we think the point does hit the layer, but we need to walk
@@ skipping 131 matching lines @@
     return NULL;
   if (!UpdateDrawProperties())
     return NULL;
   FindTouchEventLayerFunctor func = {screen_space_point};
   FindClosestMatchingLayerDataForRecursion data_for_recursion;
   FindClosestMatchingLayer(
       screen_space_point, root_layer(), func, &data_for_recursion);
   return data_for_recursion.closest_match;
 }
 
+void LayerTreeImpl::RegisterSelection(const LayerSelectionBound& anchor,
+                                      const LayerSelectionBound& focus) {
+  selection_anchor_ = anchor;
+  selection_focus_ = focus;
+}
+
+static ViewportSelectionBound ComputeViewportSelection(
+    const LayerSelectionBound& bound,
+    LayerImpl* layer,
+    float device_scale_factor) {
+  ViewportSelectionBound result;
+  result.type = bound.type;
+
+  if (!layer || bound.type == SELECTION_BOUND_EMPTY)
+    return result;
+
+  gfx::RectF layer_scaled_rect = gfx::ScaleRect(
+      bound.layer_rect, layer->contents_scale_x(), layer->contents_scale_y());
+  gfx::RectF screen_rect = MathUtil::ProjectClippedRect(
+      layer->screen_space_transform(), layer_scaled_rect);
+
+  // The bottom left of the bound is used for visibility because 1) the bound
+  // edge rect is one-dimensional (no width), and 2) the bottom is the logical
+  // focal point for bound selection handles (this may change in the future).
+  const gfx::PointF visibility_anchor = screen_rect.bottom_left();
+
+  // Using a small inclusive slop region for visibility prevents visibility

[aelias_OOO_until_Jul13, 2014/06/28 00:02:17]

Won't you still get jitter when the edge of the slop rectangle approaches the
edge of the layer?  It seems to me this won't work without some kind of
hysteresis.  As it is, I'd suggest just removing this extra logic if the
"jitter" is hard to reproduce anyway.

[jdduke (slow), 2014/06/28 00:29:10]

Yes, agreed. In fact I changed this just this afternoon.  The problem was on the
Blink side, as I was using an "enclosing rect" which was pushing us over the
layer boundary in certain cases (i.e., I was occasionally seeing -1 for the x
layer coordinate because of rounding). Should be fine without the slop now.

+  // "jitter" from floating point scaling error if a handle is on a boundary.
+  const float visibility_slop = device_scale_factor;
+  const gfx::RectF visibility_rect(visibility_anchor.x() - visibility_slop,
+                                   visibility_anchor.y() - visibility_slop,
+                                   visibility_slop * 2.f,
+                                   visibility_slop * 2.f);
+
+  float intersect_dist = 0.f;
+  result.visible =
+      PointHitsLayer(layer, visibility_rect.origin(), &intersect_dist) ||
+      PointHitsLayer(layer, visibility_rect.top_right(), &intersect_dist) ||
+      PointHitsLayer(layer, visibility_rect.bottom_left(), &intersect_dist) ||
+      PointHitsLayer(layer, visibility_rect.bottom_right(), &intersect_dist);
+
+  screen_rect.Scale(1.f / device_scale_factor);
+  result.viewport_rect = screen_rect;
+
+  return result;
+}
+
+void LayerTreeImpl::GetViewportSelection(ViewportSelectionBound* anchor,
+                                         ViewportSelectionBound* focus) {
+  DCHECK(!needs_update_draw_properties_);
+  DCHECK(anchor);
+  DCHECK(focus);
+
+  *anchor = ComputeViewportSelection(
+      selection_anchor_,
+      selection_anchor_.layer_id ? LayerById(selection_anchor_.layer_id) : NULL,
+      device_scale_factor());
+  if (anchor->type == SELECTION_BOUND_CENTER ||
+      anchor->type == SELECTION_BOUND_EMPTY) {
+    *focus = *anchor;
+  } else {
+    *focus = ComputeViewportSelection(
+        selection_focus_,
+        selection_focus_.layer_id ? LayerById(selection_focus_.layer_id) : NULL,
+        device_scale_factor());
+  }
+}
+
 void LayerTreeImpl::RegisterPictureLayerImpl(PictureLayerImpl* layer) {
   layer_tree_host_impl_->RegisterPictureLayerImpl(layer);
 }
 
 void LayerTreeImpl::UnregisterPictureLayerImpl(PictureLayerImpl* layer) {
   layer_tree_host_impl_->UnregisterPictureLayerImpl(layer);
 }
 
 }  // namespace cc