cc: Consolidate LayerList types.

cc/trees/layer_tree_host_common.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_host_common.h"
 
 #include <algorithm>
 
 #include "base/debug/trace_event.h"
 #include "cc/base/math_util.h"
 #include "cc/layers/heads_up_display_layer_impl.h"
 #include "cc/layers/layer.h"
 #include "cc/layers/layer_impl.h"
 #include "cc/layers/layer_iterator.h"
 #include "cc/layers/render_surface.h"
 #include "cc/layers/render_surface_impl.h"
 #include "cc/trees/layer_sorter.h"
 #include "cc/trees/layer_tree_impl.h"
 #include "ui/gfx/point_conversions.h"
 #include "ui/gfx/rect_conversions.h"
 #include "ui/gfx/transform.h"
 
 namespace cc {
 
 ScrollAndScaleSet::ScrollAndScaleSet() {}
 
 ScrollAndScaleSet::~ScrollAndScaleSet() {}
 
-static void SortLayers(std::vector<scoped_refptr<Layer> >::iterator forst,
-                       std::vector<scoped_refptr<Layer> >::iterator end,
+static void SortLayers(LayerList::iterator forst,
+                       LayerList::iterator end,
                        void* layer_sorter) {
   NOTREACHED();
 }
 
-static void SortLayers(std::vector<LayerImpl*>::iterator first,
-                       std::vector<LayerImpl*>::iterator end,
+static void SortLayers(LayerImplList::iterator first,
+                       LayerImplList::iterator end,
                        LayerSorter* layer_sorter) {
   DCHECK(layer_sorter);
   TRACE_EVENT0("cc", "LayerTreeHostCommon::SortLayers");
   layer_sorter->Sort(first, end);
 }
 
 inline gfx::Rect CalculateVisibleRectWithCachedLayerRect(
     gfx::Rect target_surface_rect,
     gfx::Rect layer_bound_rect,
     gfx::Rect layer_rect_in_target_space,
@@ skipping 1240 matching lines @@
   }
 }
 
 void LayerTreeHostCommon::CalculateDrawProperties(
     Layer* root_layer,
     gfx::Size device_viewport_size,
     float device_scale_factor,
     float page_scale_factor,
     int max_texture_size,
     bool can_use_lcd_text,
-    std::vector<scoped_refptr<Layer> >* render_surface_layer_list) {
+    LayerList* render_surface_layer_list) {
   gfx::Rect total_drawable_content_rect;
   gfx::Transform identity_matrix;
   gfx::Transform device_scale_transform;
   device_scale_transform.Scale(device_scale_factor, device_scale_factor);
-  std::vector<scoped_refptr<Layer> > dummy_layer_list;
+  LayerList dummy_layer_list;
 
   // The root layer's render_surface should receive the device viewport as the
   // initial clip rect.
   bool subtree_should_be_clipped = true;
   gfx::Rect device_viewport_rect(device_viewport_size);
   bool update_tile_priorities = false;
 
   // This function should have received a root layer.
   DCHECK(IsRootLayer(root_layer));
 
   PreCalculateMetaInformation<Layer>(root_layer);
   CalculateDrawPropertiesInternal<Layer,
-                                  std::vector<scoped_refptr<Layer> >,
+                                  LayerList,
                                   RenderSurface>(root_layer,
                                                  device_scale_transform,
                                                  identity_matrix,
                                                  identity_matrix,
                                                  device_viewport_rect,
                                                  device_viewport_rect,
                                                  subtree_should_be_clipped,
                                                  NULL,
                                                  render_surface_layer_list,
                                                  &dummy_layer_list,
@@ skipping 12 matching lines @@
   DCHECK(root_layer->render_surface());
 }
 
 void LayerTreeHostCommon::CalculateDrawProperties(
     LayerImpl* root_layer,
     gfx::Size device_viewport_size,
     float device_scale_factor,
     float page_scale_factor,
     int max_texture_size,
     bool can_use_lcd_text,
-    std::vector<LayerImpl*>* render_surface_layer_list,
+    LayerImplList* render_surface_layer_list,
     bool update_tile_priorities) {
   gfx::Rect total_drawable_content_rect;
   gfx::Transform identity_matrix;
   gfx::Transform device_scale_transform;
   device_scale_transform.Scale(device_scale_factor, device_scale_factor);
-  std::vector<LayerImpl*> dummy_layer_list;
+  LayerImplList dummy_layer_list;
   LayerSorter layer_sorter;
 
   // The root layer's render_surface should receive the device viewport as the
   // initial clip rect.
   bool subtree_should_be_clipped = true;
   gfx::Rect device_viewport_rect(device_viewport_size);
 
   // This function should have received a root layer.
   DCHECK(IsRootLayer(root_layer));
 
   PreCalculateMetaInformation<LayerImpl>(root_layer);
   CalculateDrawPropertiesInternal<LayerImpl,
-                                  std::vector<LayerImpl*>,
+                                  LayerImplList,
                                   RenderSurfaceImpl>(
       root_layer,
       device_scale_transform,
       identity_matrix,
       identity_matrix,
       device_viewport_rect,
       device_viewport_rect,
       subtree_should_be_clipped,
       NULL,
       render_surface_layer_list,
@@ skipping 98 matching lines @@
     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;
 }
 
 LayerImpl* LayerTreeHostCommon::FindLayerThatIsHitByPoint(
     gfx::PointF screen_space_point,
-    const std::vector<LayerImpl*>& render_surface_layer_list) {
+    const LayerImplList& render_surface_layer_list) {
   LayerImpl* found_layer = NULL;
 
   typedef LayerIterator<LayerImpl,
-                        std::vector<LayerImpl*>,
+                        LayerImplList,
                         RenderSurfaceImpl,
                         LayerIteratorActions::FrontToBack> LayerIteratorType;
   LayerIteratorType end = LayerIteratorType::End(&render_surface_layer_list);
 
   for (LayerIteratorType
            it = LayerIteratorType::Begin(&render_surface_layer_list);
        it != end;
        ++it) {
     // We don't want to consider render_surfaces for hit testing.
     if (!it.represents_itself())
@@ skipping 21 matching lines @@
     break;
   }
 
   // This can potentially return NULL, which means the screen_space_point did
   // not successfully hit test any layers, not even the root layer.
   return found_layer;
 }
 
 LayerImpl* LayerTreeHostCommon::FindLayerThatIsHitByPointInTouchHandlerRegion(
     gfx::PointF screen_space_point,
-    const std::vector<LayerImpl*>& render_surface_layer_list) {
+    const LayerImplList& render_surface_layer_list) {
   LayerImpl* found_layer = NULL;
 
   typedef LayerIterator<LayerImpl,
-                        std::vector<LayerImpl*>,
+                        LayerImplList,
                         RenderSurfaceImpl,
                         LayerIteratorActions::FrontToBack> LayerIteratorType;
   LayerIteratorType end = LayerIteratorType::End(&render_surface_layer_list);
 
   for (LayerIteratorType
            it = LayerIteratorType::Begin(&render_surface_layer_list);
        it != end;
        ++it) {
     // We don't want to consider render_surfaces for hit testing.
     if (!it.represents_itself())
@@ skipping 29 matching lines @@
   // At this point, we think the point does hit the touch event handler region
   // on the layer, but we need to walk up the parents to ensure that the layer
   // was not clipped in such a way that the hit point actually should not hit
   // the layer.
   if (PointIsClippedBySurfaceOrClipRect(screen_space_point, layer_impl))
     return false;
 
   return true;
 }
 }  // namespace cc