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/file_path.h"
 #include "base/file_util.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/path_service.h"
@@ skipping 16 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),
+  explicit ColoredLayer(SkColor color)
+      : 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 107 matching lines @@
 
 #if defined(OS_WIN)
 // These are disabled on windows as they don't run correctly on the buildbot.
 // Reenable once we move to the real compositor.
 #define MAYBE_Delegate DISABLED_Delegate
 #define MAYBE_Draw DISABLED_Draw
 #define MAYBE_DrawTree DISABLED_DrawTree
 #define MAYBE_Hierarchy DISABLED_Hierarchy
 #define MAYBE_HierarchyNoTexture DISABLED_HierarchyNoTexture
 #define MAYBE_DrawPixels DISABLED_DrawPixels
+#define MAYBE_SetRootLayer DISABLED_SetRootLayer
 #else
 #define MAYBE_Delegate Delegate
 #define MAYBE_Draw Draw
 #define MAYBE_DrawTree DrawTree
 #define MAYBE_Hierarchy Hierarchy
 #define MAYBE_HierarchyNoTexture HierarchyNoTexture
 #define MAYBE_DrawPixels DrawPixels
+#define MAYBE_SetRootLayer SetRootLayer
 #endif
 
 TEST_F(LayerWithRealCompositorTest, MAYBE_Draw) {
   scoped_ptr<Layer> layer(CreateColorLayer(SK_ColorRED,
                                            gfx::Rect(20, 20, 50, 50)));
   DrawTree(layer.get());
 }
 
 // Create this hierarchy:
 // L1 - red
@@ skipping 27 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 406 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 88 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);
 }
 
+// Checks the logic around Compositor::SetRootLayer and Layer::SetCompositor.
+TEST_F(LayerWithRealCompositorTest, MAYBE_SetRootLayer) {
+  Compositor* compositor = GetCompositor();
+  Layer l1;
+  EXPECT_EQ(NULL, l1.GetCompositor());
+
+  Layer l2;
+  EXPECT_EQ(NULL, l2.GetCompositor());
+
+  compositor->SetRootLayer(&l1);
+  EXPECT_EQ(compositor, l1.GetCompositor());
+
+  l1.Add(&l2);
+  EXPECT_EQ(compositor, l2.GetCompositor());
+
+  l1.Remove(&l2);
+  EXPECT_EQ(NULL, l2.GetCompositor());
+
+  l1.Add(&l2);
+  EXPECT_EQ(compositor, l2.GetCompositor());
+
+  compositor->SetRootLayer(NULL);
+  EXPECT_EQ(NULL, l1.GetCompositor());
+  EXPECT_EQ(NULL, l2.GetCompositor());
+}
+
 } // namespace ui