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 101 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();
+
   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();
+
   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 11 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(
+      start_selection_layer_ ? start_selection_layer_->id() : 0,
+      start_selection_handle_,
+      end_selection_layer_ ? end_selection_layer_->id() : 0,
+      end_selection_handle_);
+
   // 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 788 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(0, SelectionHandle(), 0, SelectionHandle());
+}
+
 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 60 matching lines @@
   // 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 bool PointIsClippedBySurfaceOrClipRect(
     const gfx::PointF& screen_space_point,
-    LayerImpl* layer) {
-  LayerImpl* current_layer = layer;
+    const LayerImpl* layer) {
+  const LayerImpl* current_layer = layer;
 
   // Walk up the layer tree and hit-test any render_surfaces and any layer
   // clip rects that are active.
   while (current_layer) {
     if (current_layer->render_surface() &&
         !PointHitsRect(
             screen_space_point,
             current_layer->render_surface()->screen_space_transform(),
             current_layer->render_surface()->content_rect(),
             NULL))
       return true;
 
     // Note that drawable content rects are actually in target surface space, so
     // the transform we have to provide is the target surface's
     // screen_space_transform.
-    LayerImpl* render_target = current_layer->render_target();
+    const LayerImpl* render_target = current_layer->render_target();
     if (LayerClipsSubtree(current_layer) &&
         !PointHitsRect(
             screen_space_point,
             render_target->render_surface()->screen_space_transform(),
             current_layer->drawable_content_rect(),
             NULL))
       return true;
 
     current_layer = current_layer->parent();
   }
 
   // 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 123 matching lines @@
 
 LayerImpl* LayerTreeImpl::FindLayerThatIsHitByPointInTouchHandlerRegion(
     const gfx::PointF& screen_space_point) {
   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(int start_layer_id,
+                                      const SelectionHandle& start_handle,
+                                      int end_layer_id,
+                                      const SelectionHandle& end_handle) {
+  start_selection_layer_ = start_layer_id ? LayerById(start_layer_id) : NULL;
+  end_selection_layer_ = end_layer_id ? LayerById(end_layer_id) : NULL;
+  start_selection_handle_ = start_handle;
+  end_selection_handle_ = end_handle;
+}
+
+static SelectionHandle ComputeSelectionVisibility(const SelectionHandle& handle,
+                                                  const LayerImpl* layer,
+                                                  float device_scale_factor) {
+  if (!layer || handle.type == SelectionHandle::NONE ||
+      handle.type == SelectionHandle::IGNORED)
+    return handle;
+
+  SelectionHandle result = handle;
+
+  gfx::QuadF layer_scaled_quad(gfx::ScaleRect(
+      handle.bounds, layer->contents_scale_x(), layer->contents_scale_y()));
+  bool handle_clipped = false;
+  gfx::QuadF screen_quad = MathUtil::ProjectQuad(
+      layer->screen_space_transform(), layer_scaled_quad, &handle_clipped);
+  screen_quad.Scale(1.f / device_scale_factor);
+  result.bounds = screen_quad.BoundingBox();
+
+  // Use the bottom-left coordinate as the visibility anchor point.
+  result.visible = !handle_clipped &&

[jdduke (slow), 2014/06/02 20:06:01]

Bah, figured it out, need to be doing the clip test in pixel screen space
(before coords converted to DIPs).

+                   !PointIsClippedBySurfaceOrClipRect(screen_quad.p4(), layer);
+
+  return result;
+}
+
+void LayerTreeImpl::GetViewportSelection(SelectionHandle* start_handle,
+                                         SelectionHandle* end_handle) {
+  DCHECK(!needs_update_draw_properties_);
+  DCHECK(start_handle);
+  DCHECK(end_handle);
+
+  *start_handle = ComputeSelectionVisibility(
+      start_selection_handle_, start_selection_layer_, device_scale_factor());
+
+  if (start_handle->type == SelectionHandle::CENTER ||
+      start_handle->type == SelectionHandle::NONE ||
+      start_handle->type == SelectionHandle::IGNORED) {
+    *end_handle = *start_handle;
+  } else {
+    *end_handle = ComputeSelectionVisibility(
+        end_selection_handle_, end_selection_layer_, device_scale_factor());
+  }
+}
+
 }  // namespace cc