Fix stale compositor references from ui::Layer

ui/gfx/compositor/layer_unittest.cc

 // Copyright (c) 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 "base/basictypes.h"
 #include "base/compiler_specific.h"
 #include "base/memory/scoped_ptr.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/gfx/canvas_skia.h"
 #include "ui/gfx/compositor/compositor_observer.h"
@@ skipping 11 matching lines @@
 // - LayerWithNullDelegateTest uses TestCompositor and NullLayerDelegate as the
 //   LayerDelegate. This is typically the base class you want to use.
 // - LayerWithDelegateTest uses TestCompositor and does not set a LayerDelegate
 //   on the delegates.
 // - LayerWithRealCompositorTest when a real compositor is required for testing.
 //    - Slow because they bring up a window and run the real compositor. This
 //      is typically not what you want.
 
 class ColoredLayer : public Layer, public LayerDelegate {
  public:
-  ColoredLayer(Compositor* compositor, SkColor color)
-      : Layer(compositor, Layer::LAYER_HAS_TEXTURE),
+  ColoredLayer(SkColor color)

[sky, 2011/11/15 04:57:04]

explicit

[piman, 2011/11/15 22:06:33]

Done.

+      : Layer(Layer::LAYER_HAS_TEXTURE),
         color_(color) {
     set_delegate(this);
   }
 
   virtual ~ColoredLayer() { }
 
   // Overridden from LayerDelegate:
   virtual void OnPaintLayer(gfx::Canvas* canvas) OVERRIDE {
     canvas->GetSkCanvas()->drawColor(color_);
   }
@@ skipping 15 matching lines @@
   }
 
   virtual void TearDown() OVERRIDE {
   }
 
   Compositor* GetCompositor() {
     return window_->GetCompositor();
   }
 
   Layer* CreateLayer(Layer::LayerType type) {
-    return new Layer(GetCompositor(), type);
+    return new Layer(type);
   }
 
   Layer* CreateColorLayer(SkColor color, const gfx::Rect& bounds) {
-    Layer* layer = new ColoredLayer(GetCompositor(), color);
+    Layer* layer = new ColoredLayer(color);
     layer->SetBounds(bounds);
     return layer;
   }
 
   Layer* CreateNoTextureLayer(const gfx::Rect& bounds) {
     Layer* layer = CreateLayer(Layer::LAYER_HAS_NO_TEXTURE);
     layer->SetBounds(bounds);
     return layer;
   }
 
@@ skipping 147 matching lines @@
   virtual void SetUp() OVERRIDE {
     compositor_ = new TestCompositor(this);
   }
 
   virtual void TearDown() OVERRIDE {
   }
 
   Compositor* compositor() { return compositor_.get(); }
 
   virtual Layer* CreateLayer(Layer::LayerType type) {
-    return new Layer(compositor(), type);
+    return new Layer(type);
   }
 
   Layer* CreateColorLayer(SkColor color, const gfx::Rect& bounds) {
-    Layer* layer = new ColoredLayer(compositor(), color);
+    Layer* layer = new ColoredLayer(color);
     layer->SetBounds(bounds);
     return layer;
   }
 
   virtual Layer* CreateNoTextureLayer(const gfx::Rect& bounds) {
     Layer* layer = CreateLayer(Layer::LAYER_HAS_NO_TEXTURE);
     layer->SetBounds(bounds);
     return layer;
   }
 
@@ skipping 179 matching lines @@
   // Overridden from testing::Test:
   virtual void SetUp() OVERRIDE {
     LayerWithDelegateTest::SetUp();
     default_layer_delegate_.reset(new NullLayerDelegate());
   }
 
   virtual void TearDown() OVERRIDE {
   }
 
   Layer* CreateLayer(Layer::LayerType type) OVERRIDE {
-    Layer* layer = new Layer(compositor(), type);
+    Layer* layer = new Layer(type);
     layer->set_delegate(default_layer_delegate_.get());
     return layer;
   }
 
   Layer* CreateTextureRootLayer(const gfx::Rect& bounds) {
     Layer* layer = CreateTextureLayer(bounds);
     compositor()->SetRootLayer(layer);
     return layer;
   }
 
@@ skipping 230 matching lines @@
 
   // Toggling l2's visibility should drop all sub-layer textures.
   l12->SetVisible(false);
   EXPECT_EQ(NULL, l12->texture());
   EXPECT_EQ(NULL, l121->texture());
   EXPECT_EQ(NULL, l122->texture());
 }
 
 // Various visibile/drawn assertions.
 TEST_F(LayerWithNullDelegateTest, Visibility) {
-  scoped_ptr<Layer> l1(new Layer(NULL, Layer::LAYER_HAS_TEXTURE));
-  scoped_ptr<Layer> l2(new Layer(NULL, Layer::LAYER_HAS_TEXTURE));
-  scoped_ptr<Layer> l3(new Layer(NULL, Layer::LAYER_HAS_TEXTURE));
+  scoped_ptr<Layer> l1(new Layer(Layer::LAYER_HAS_TEXTURE));
+  scoped_ptr<Layer> l2(new Layer(Layer::LAYER_HAS_TEXTURE));
+  scoped_ptr<Layer> l3(new Layer(Layer::LAYER_HAS_TEXTURE));
   l1->Add(l2.get());
   l2->Add(l3.get());
 
   NullLayerDelegate delegate;
   l1->set_delegate(&delegate);
   l2->set_delegate(&delegate);
   l3->set_delegate(&delegate);
 
   // Layers should initially be drawn.
   EXPECT_TRUE(l1->IsDrawn());
@@ skipping 89 matching lines @@
   SkAutoLockPixels lock(bitmap);
   bool is_all_red = true;
   for (int x = 0; is_all_red && x < 500; x++)
     for (int y = 0; is_all_red && y < 500; y++)
       is_all_red = is_all_red && (bitmap.getColor(x, y) == SK_ColorRED);
 
   EXPECT_TRUE(is_all_red);
 }
 
 } // namespace ui