cc: Consolidate LayerList types.

cc/layers/layer_impl.h

 // 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.
 
 #ifndef CC_LAYERS_LAYER_IMPL_H_
 #define CC_LAYERS_LAYER_IMPL_H_
 
 #include <string>
 
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/values.h"
 #include "cc/animation/layer_animation_controller.h"
 #include "cc/animation/layer_animation_value_observer.h"
 #include "cc/base/cc_export.h"
 #include "cc/base/region.h"
 #include "cc/base/scoped_ptr_vector.h"
 #include "cc/input/input_handler.h"
 #include "cc/layers/draw_properties.h"
+#include "cc/layers/layer_lists.h"
 #include "cc/layers/render_surface_impl.h"
 #include "cc/quads/render_pass.h"
 #include "cc/quads/shared_quad_state.h"
 #include "cc/resources/resource_provider.h"
 #include "skia/ext/refptr.h"
 #include "third_party/WebKit/Source/Platform/chromium/public/WebFilterOperations.h"
 #include "third_party/skia/include/core/SkColor.h"
 #include "third_party/skia/include/core/SkImageFilter.h"
 #include "third_party/skia/include/core/SkPicture.h"
 #include "ui/gfx/rect.h"
@@ skipping 11 matching lines @@
 class QuadSink;
 class Renderer;
 class ScrollbarAnimationController;
 class ScrollbarLayerImpl;
 class Layer;
 
 struct AppendQuadsData;
 
 class CC_EXPORT LayerImpl : LayerAnimationValueObserver {
  public:
-  typedef ScopedPtrVector<LayerImpl> LayerList;
-
   static scoped_ptr<LayerImpl> Create(LayerTreeImpl* tree_impl, int id) {
     return make_scoped_ptr(new LayerImpl(tree_impl, id));
   }
 
   virtual ~LayerImpl();
 
   int id() const { return layer_id_; }
 
   // LayerAnimationValueObserver implementation.
   virtual void OnOpacityAnimated(float opacity) OVERRIDE;
   virtual void OnTransformAnimated(const gfx::Transform& transform) OVERRIDE;
   virtual bool IsActive() const OVERRIDE;
 
   // Tree structure.
   LayerImpl* parent() { return parent_; }
   const LayerImpl* parent() const { return parent_; }
-  const LayerList& children() const { return children_; }
-  LayerList& children() { return children_; }
+  const OwnedLayerImplList& children() const { return children_; }
+  OwnedLayerImplList& children() { return children_; }
   LayerImpl* child_at(size_t index) const { return children_[index]; }
   void AddChild(scoped_ptr<LayerImpl> child);
   scoped_ptr<LayerImpl> RemoveChild(LayerImpl* child);
   void set_parent(LayerImpl* parent) { parent_ = parent; }
   // Warning: This does not preserve tree structure invariants.
   void ClearChildList();
 
   void SetMaskLayer(scoped_ptr<LayerImpl> mask_layer);
   LayerImpl* mask_layer() { return mask_layer_.get(); }
   const LayerImpl* mask_layer() const { return mask_layer_.get(); }
@@ skipping 104 matching lines @@
   // Debug layer name.
   void SetDebugName(const std::string& debug_name) { debug_name_ = debug_name; }
   std::string debug_name() const { return debug_name_; }
 
   bool ShowDebugBorders() const;
 
   // These invalidate the host's render surface layer list.  The caller
   // is responsible for calling set_needs_update_draw_properties on the tree
   // so that its list can be recreated.
   void CreateRenderSurface();
-  void ClearRenderSurface() { draw_properties_.render_surface.reset(); }
+  void ClearRenderSurface();
 
   DrawProperties<LayerImpl, RenderSurfaceImpl>& draw_properties() {
     return draw_properties_;
   }
   const DrawProperties<LayerImpl, RenderSurfaceImpl>& draw_properties() const {
     return draw_properties_;
   }
 
   // The following are shortcut accessors to get various information from
   // draw_properties_
@@ skipping 212 matching lines @@
 
  private:
   void UpdateScrollbarPositions();
 
   virtual const char* LayerTypeAsString() const;
 
   void DumpLayer(std::string* str, int indent) const;
 
   // Properties internal to LayerImpl
   LayerImpl* parent_;
-  LayerList children_;
+  OwnedLayerImplList children_;
   // mask_layer_ can be temporarily stolen during tree sync, we need this ID to
   // confirm newly assigned layer is still the previous one
   int mask_layer_id_;
   scoped_ptr<LayerImpl> mask_layer_;
   int replica_layer_id_;  // ditto
   scoped_ptr<LayerImpl> replica_layer_;
   int layer_id_;
   LayerTreeImpl* layer_tree_impl_;
 
   // Properties synchronized from the associated Layer.
@@ skipping 81 matching lines @@
   // Group of properties that need to be computed based on the layer tree
   // hierarchy before layers can be drawn.
   DrawProperties<LayerImpl, RenderSurfaceImpl> draw_properties_;
 
   DISALLOW_COPY_AND_ASSIGN(LayerImpl);
 };
 
 }  // namespace cc
 
 #endif  // CC_LAYERS_LAYER_IMPL_H_