Rename composited selection anchor/focus to start/end

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 193 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_);
+  target_tree->RegisterSelection(selection_start_, selection_end_);
 
   // 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
@@ skipping 1079 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;
+void LayerTreeImpl::RegisterSelection(const LayerSelectionBound& start,
+                                      const LayerSelectionBound& end) {
+  selection_start_ = start;
+  selection_end_ = end;
 }
 
 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)
@@ skipping 10 matching lines @@
   const gfx::PointF& visibility_point = screen_rect.bottom_left();
   float intersect_distance = 0.f;
   result.visible = PointHitsLayer(layer, visibility_point, &intersect_distance);
 
   screen_rect.Scale(1.f / device_scale_factor);
   result.viewport_rect = screen_rect;
 
   return result;
 }
 
-void LayerTreeImpl::GetViewportSelection(ViewportSelectionBound* anchor,
-                                         ViewportSelectionBound* focus) {
-  DCHECK(anchor);
-  DCHECK(focus);
+void LayerTreeImpl::GetViewportSelection(ViewportSelectionBound* start,
+                                         ViewportSelectionBound* end) {
+  DCHECK(start);
+  DCHECK(end);
 
-  *anchor = ComputeViewportSelection(
-      selection_anchor_,
-      selection_anchor_.layer_id ? LayerById(selection_anchor_.layer_id) : NULL,
+  *start = ComputeViewportSelection(
+      selection_start_,
+      selection_start_.layer_id ? LayerById(selection_start_.layer_id) : NULL,
       device_scale_factor());
-  if (anchor->type == SELECTION_BOUND_CENTER ||
-      anchor->type == SELECTION_BOUND_EMPTY) {
-    *focus = *anchor;
+  if (start->type == SELECTION_BOUND_CENTER ||
+      start->type == SELECTION_BOUND_EMPTY) {
+    *end = *start;
   } else {
-    *focus = ComputeViewportSelection(
-        selection_focus_,
-        selection_focus_.layer_id ? LayerById(selection_focus_.layer_id) : NULL,
+    *end = ComputeViewportSelection(
+        selection_end_,
+        selection_end_.layer_id ? LayerById(selection_end_.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