cc: Consolidate LayerList types.

cc/trees/layer_tree_host_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_host_impl.h"
 
 #include <algorithm>
 
 #include "base/basictypes.h"
 #include "base/debug/trace_event.h"
 #include "base/json/json_writer.h"
 #include "base/metrics/histogram.h"
 #include "base/stl_util.h"
 #include "base/stringprintf.h"
 #include "cc/animation/scrollbar_animation_controller.h"
 #include "cc/base/math_util.h"
 #include "cc/base/util.h"
 #include "cc/debug/debug_rect_history.h"
 #include "cc/debug/frame_rate_counter.h"
 #include "cc/debug/overdraw_metrics.h"
 #include "cc/debug/paint_time_counter.h"
 #include "cc/debug/rendering_stats_instrumentation.h"
 #include "cc/input/page_scale_animation.h"
 #include "cc/input/top_controls_manager.h"
 #include "cc/layers/append_quads_data.h"
 #include "cc/layers/heads_up_display_layer_impl.h"
+#include "cc/layers/layer_impl.h"
 #include "cc/layers/layer_iterator.h"
+#include "cc/layers/render_surface_impl.h"
 #include "cc/layers/scrollbar_layer_impl.h"
 #include "cc/output/compositor_frame_metadata.h"
 #include "cc/output/delegating_renderer.h"
 #include "cc/output/gl_renderer.h"
 #include "cc/output/software_renderer.h"
 #include "cc/quads/render_pass_draw_quad.h"
 #include "cc/quads/shared_quad_state.h"
 #include "cc/quads/solid_color_draw_quad.h"
 #include "cc/resources/memory_history.h"
 #include "cc/resources/picture_layer_tiling.h"
@@ skipping 319 matching lines @@
     if (LayerTreeHostCommon::LayerHasTouchEventHandlersAt(device_viewport_point,
                                                           layer_impl))
       return true;
   }
 
   return false;
 }
 
 void LayerTreeHostImpl::TrackDamageForAllSurfaces(
     LayerImpl* root_draw_layer,
-    const LayerList& render_surface_layer_list) {
+    const LayerImplList& render_surface_layer_list) {
   // For now, we use damage tracking to compute a global scissor. To do this, we
   // must compute all damage tracking before drawing anything, so that we know
   // the root damage rect. The root damage rect is then used to scissor each
   // surface.
 
   for (int surface_index = render_surface_layer_list.size() - 1;
        surface_index >= 0;
        --surface_index) {
     LayerImpl* render_surface_layer = render_surface_layer_list[surface_index];
     RenderSurfaceImpl* render_surface = render_surface_layer->render_surface();
@@ skipping 154 matching lines @@
         &frame->occluding_screen_space_rects);
   }
   if (debug_state_.show_non_occluding_rects) {
     occlusion_tracker.set_non_occluding_screen_space_rects_container(
         &frame->non_occluding_screen_space_rects);
   }
 
   // Add quads to the Render passes in FrontToBack order to allow for testing
   // occlusion and performing culling during the tree walk.
   typedef LayerIterator<LayerImpl,
-                        std::vector<LayerImpl*>,
+                        LayerImplList,
                         RenderSurfaceImpl,
                         LayerIteratorActions::FrontToBack> LayerIteratorType;
 
   // Typically when we are missing a texture and use a checkerboard quad, we
   // still draw the frame. However when the layer being checkerboarded is moving
   // due to an impl-animation, we drop the frame to avoid flashing due to the
   // texture suddenly appearing in the future.
   bool draw_frame = true;
 
   int layers_drawn = 0;
@@ skipping 1480 matching lines @@
 
 // static
 LayerImpl* LayerTreeHostImpl::GetNonCompositedContentLayerRecursive(
     LayerImpl* layer) {
   if (!layer)
     return NULL;
 
   if (layer->DrawsContent())
     return layer;
 
-  for (LayerImpl::LayerList::const_iterator it = layer->children().begin();
+  for (LayerImplList::const_iterator it = layer->children().begin();
        it != layer->children().end(); ++it) {
     LayerImpl* nccr = GetNonCompositedContentLayerRecursive(*it);
     if (nccr)
       return nccr;
   }
 
   return NULL;
 }
 
 skia::RefPtr<SkPicture> LayerTreeHostImpl::CapturePicture() {
   LayerTreeImpl* tree =
       pending_tree_ ? pending_tree_.get() : active_tree_.get();
   LayerImpl* layer = GetNonCompositedContentLayerRecursive(tree->root_layer());
   return layer ? layer->GetPicture() : skia::RefPtr<SkPicture>();
 }
 
 void LayerTreeHostImpl::SetDebugState(const LayerTreeDebugState& debug_state) {
   if (debug_state_.continuous_painting != debug_state.continuous_painting)
     paint_time_counter_->ClearHistory();
 
   debug_state_ = debug_state;
 }
 
 }  // namespace cc