Replace cc::ViewportSelectionBound with gfx::SelectionBound

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 <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 821 matching lines @@
 
   if (!root_layer())
     return false;
 
   {
     base::ElapsedTimer timer;
     TRACE_EVENT2(
         "cc", "LayerTreeImpl::UpdateDrawProperties::CalculateDrawProperties",
         "IsActive", IsActiveTree(), "SourceFrameNumber", source_frame_number_);
     bool can_render_to_separate_surface =
-        (!is_in_resourceless_software_draw_mode());
+        (layer_tree_host_impl_->GetDrawMode() !=
+         DRAW_MODE_RESOURCELESS_SOFTWARE);
 
     LayerTreeHostCommon::CalcDrawPropsImplInputs inputs(
         root_layer(), DrawViewportSize(),
         layer_tree_host_impl_->DrawTransform(), device_scale_factor(),
         current_page_scale_factor(), PageScaleLayer(),
         InnerViewportScrollLayer(), OuterViewportScrollLayer(),
         elastic_overscroll()->Current(IsActiveTree()),
         OverscrollElasticityLayer(), resource_provider()->max_texture_size(),
         can_render_to_separate_surface,
         settings().layer_transforms_should_scale_layer_contents,
@@ skipping 91 matching lines @@
                                    : layer_tree_host_impl_->pending_tree();
     // If this is not the sync tree, then it is not safe to update lcd text
     // as it causes invalidations and the tiles may be in use.
     DCHECK_EQ(this, sync_tree);
     for (const auto& layer : picture_layers_)
       layer->UpdateCanUseLCDTextAfterCommit();
   }
 
   // Resourceless draw do not need tiles and should not affect existing tile
   // priorities.
-  if (!is_in_resourceless_software_draw_mode()) {
+  if (layer_tree_host_impl_->GetDrawMode() != DRAW_MODE_RESOURCELESS_SOFTWARE) {
     TRACE_EVENT_BEGIN2("cc", "LayerTreeImpl::UpdateDrawProperties::UpdateTiles",
                        "IsActive", IsActiveTree(), "SourceFrameNumber",
                        source_frame_number_);
     size_t layers_updated_count = 0;
     bool tile_priorities_updated = false;
     for (PictureLayerImpl* layer : picture_layers_) {
       if (!layer->is_drawn_render_surface_layer_list_member())
         continue;
       ++layers_updated_count;
       tile_priorities_updated |= layer->UpdateTiles();
@@ skipping 648 matching lines @@
   for (const ClipNode* clip_node = clip_tree.Node(layer->clip_tree_index());
        clip_node->id > 1; clip_node = clip_tree.parent(clip_node)) {
     if (clip_node->data.applies_local_clip) {
       const TransformNode* transform_node =
           transform_tree.Node(clip_node->data.target_id);
       gfx::Rect combined_clip_in_target_space =
           gfx::ToEnclosingRect(clip_node->data.combined_clip_in_target_space);
 
       const LayerImpl* target_layer =
           layer->layer_tree_impl()->LayerById(transform_node->owner_id);
-      DCHECK(transform_node->id == 0 || target_layer->render_surface() ||
-             layer->layer_tree_impl()->is_in_resourceless_software_draw_mode());
+      DCHECK(transform_node->id == 0 || target_layer->render_surface());
       gfx::Transform surface_screen_space_transform =
-          transform_node->id == 0 ||
-                  (layer->layer_tree_impl()
-                       ->is_in_resourceless_software_draw_mode())
+          transform_node->id == 0
               ? gfx::Transform()
               : SurfaceScreenSpaceTransform(target_layer, transform_tree);
       if (!PointHitsRect(screen_space_point, surface_screen_space_transform,
                          combined_clip_in_target_space, NULL)) {
         return true;
       }
     }
     const LayerImpl* clip_node_owner =
         layer->layer_tree_impl()->LayerById(clip_node->owner_id);
     if (clip_node_owner->render_surface() &&
@@ skipping 184 matching lines @@
   FindClosestMatchingLayer(screen_space_point, root_layer(), func,
                            property_trees_.transform_tree,
                            property_trees_.clip_tree, &state);
   return state.closest_match;
 }
 
 void LayerTreeImpl::RegisterSelection(const LayerSelection& selection) {
   selection_ = selection;
 }
 
-static ViewportSelectionBound ComputeViewportSelectionBound(
+static gfx::SelectionBound ComputeViewportSelectionBound(
     const LayerSelectionBound& layer_bound,
     LayerImpl* layer,
     float device_scale_factor,
     const TransformTree& transform_tree,
     const ClipTree& clip_tree) {
-  ViewportSelectionBound viewport_bound;
-  viewport_bound.type = layer_bound.type;
+  gfx::SelectionBound viewport_bound;
+  viewport_bound.set_type(
+      static_cast<gfx::SelectionBound::Type>(layer_bound.type));
 
   if (!layer || layer_bound.type == SELECTION_BOUND_EMPTY)
     return viewport_bound;
 
   auto layer_top = gfx::PointF(layer_bound.edge_top);
   auto layer_bottom = gfx::PointF(layer_bound.edge_bottom);
   gfx::Transform screen_space_transform = layer->ScreenSpaceTransform();
 
   bool clipped = false;
   gfx::PointF screen_top =
       MathUtil::MapPoint(screen_space_transform, layer_top, &clipped);
   gfx::PointF screen_bottom =
       MathUtil::MapPoint(screen_space_transform, layer_bottom, &clipped);
 
   // MapPoint can produce points with NaN components (even when no inputs are
-  // NaN). Since consumers of ViewportSelectionBounds may round |edge_top| or
+  // NaN). Since consumers of gfx::SelectionBounds may round |edge_top| or
   // |edge_bottom| (and since rounding will crash on NaN), we return an empty
   // bound instead.
   if (std::isnan(screen_top.x()) || std::isnan(screen_top.y()) ||
       std::isnan(screen_bottom.x()) || std::isnan(screen_bottom.y()))
-    return ViewportSelectionBound();
+    return gfx::SelectionBound();
 
   const float inv_scale = 1.f / device_scale_factor;
-  viewport_bound.edge_top = gfx::ScalePoint(screen_top, inv_scale);
-  viewport_bound.edge_bottom = gfx::ScalePoint(screen_bottom, inv_scale);
+  viewport_bound.SetEdgeTop(gfx::ScalePoint(screen_top, inv_scale));
+  viewport_bound.SetEdgeBottom(gfx::ScalePoint(screen_bottom, inv_scale));
 
   // The bottom edge point is used for visibility testing as it is the logical
   // focal point for bound selection handles (this may change in the future).
   // Shifting the visibility point fractionally inward ensures that neighboring
   // or logically coincident layers aligned to integral DPI coordinates will not
   // spuriously occlude the bound.
   gfx::Vector2dF visibility_offset = layer_top - layer_bottom;
   visibility_offset.Scale(device_scale_factor / visibility_offset.Length());
   gfx::PointF visibility_point = layer_bottom + visibility_offset;
   if (visibility_point.x() <= 0)
     visibility_point.set_x(visibility_point.x() + device_scale_factor);
   visibility_point =
       MathUtil::MapPoint(screen_space_transform, visibility_point, &clipped);
 
   float intersect_distance = 0.f;
-  viewport_bound.visible = PointHitsLayer(
-      layer, visibility_point, &intersect_distance, transform_tree, clip_tree);
+  viewport_bound.set_visible(PointHitsLayer(
+      layer, visibility_point, &intersect_distance, transform_tree, clip_tree));
 
   return viewport_bound;
 }
 
-void LayerTreeImpl::GetViewportSelection(ViewportSelection* selection) {
+void LayerTreeImpl::GetViewportSelection(
+    Selection<gfx::SelectionBound>* selection) {
   DCHECK(selection);
 
   selection->start = ComputeViewportSelectionBound(
       selection_.start,
       selection_.start.layer_id ? LayerById(selection_.start.layer_id) : NULL,
       device_scale_factor(), property_trees_.transform_tree,
       property_trees_.clip_tree);
   selection->is_editable = selection_.is_editable;
   selection->is_empty_text_form_control = selection_.is_empty_text_form_control;
-  if (selection->start.type == SELECTION_BOUND_CENTER ||
-      selection->start.type == SELECTION_BOUND_EMPTY) {
+  if (selection->start.type() == gfx::SelectionBound::CENTER ||
+      selection->start.type() == gfx::SelectionBound::EMPTY) {
     selection->end = selection->start;
   } else {
     selection->end = ComputeViewportSelectionBound(
         selection_.end,
         selection_.end.layer_id ? LayerById(selection_.end.layer_id) : NULL,
         device_scale_factor(), property_trees_.transform_tree,
         property_trees_.clip_tree);
   }
 }
 
@@ skipping 146 matching lines @@
 }
 
 void LayerTreeImpl::ResetAllChangeTracking() {
   layers_that_should_push_properties_.clear();
   for (auto* layer : *this)
     layer->ResetChangeTracking();
   property_trees_.ResetAllChangeTracking();
 }
 
 }  // namespace cc