Added a unittest for compositor observers.

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 155 matching lines @@
   virtual ~NullLayerDelegate() {}
 
  private:
   // Overridden from LayerDelegate:
   virtual void OnPaintLayer(gfx::Canvas* canvas) OVERRIDE {
   }
 
   DISALLOW_COPY_AND_ASSIGN(NullLayerDelegate);
 };
 
+// Remembers if it has been notified.
+class TestCompositorObserver : public CompositorObserver {
+ public:
+  TestCompositorObserver() : notified_(false) {}
+
+  bool notified() const { return notified_; }
+
+  void Reset() { notified_ = false; }
+
+ private:
+  virtual void OnCompositingEnded(Compositor* compositor) OVERRIDE {
+    notified_ = true;
+  }
+
+  bool notified_;
+
+  DISALLOW_COPY_AND_ASSIGN(TestCompositorObserver);
+};
+
 }
 
 #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_CompositorObservers DISABLED_CompositorObservers
 #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_CompositorObservers CompositorObservers
 #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 593 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 that compositor observers are notified when:
+// - DrawTree is called,
+// - After ScheduleDraw is called, or
+// - Whenever SetBounds, SetOpacity or SetTransform are called.
+// TODO(vollick): could be reorganized into compositor_unittest.cc
+TEST_F(LayerWithRealCompositorTest, MAYBE_CompositorObservers) {
+  scoped_ptr<Layer> l1(CreateColorLayer(SK_ColorRED,
+                                        gfx::Rect(20, 20, 400, 400)));
+  scoped_ptr<Layer> l2(CreateColorLayer(SK_ColorBLUE,
+                                        gfx::Rect(10, 10, 350, 350)));
+  l1->Add(l2.get());
+  TestCompositorObserver observer;
+  GetCompositor()->AddObserver(&observer);
+
+  // Explicitly called DrawTree should cause the observers to be notified.
+  // NOTE: this call to DrawTree sets l1 to be the compositor's root layer.
+  DrawTree(l1.get());
+  RunPendingMessages();
+  EXPECT_TRUE(observer.notified());
+
+  // As should scheduling a draw and waiting.
+  observer.Reset();
+  l1->ScheduleDraw();
+  RunPendingMessages();
+  EXPECT_TRUE(observer.notified());
+
+  // Moving, but not resizing, a layer should alert the observers.
+  observer.Reset();
+  l2->SetBounds(gfx::Rect(0, 0, 350, 350));
+  RunPendingMessages();
+  EXPECT_TRUE(observer.notified());
+
+  // So should resizing a layer.
+  observer.Reset();
+  l2->SetBounds(gfx::Rect(0, 0, 400, 400));
+  RunPendingMessages();
+  EXPECT_TRUE(observer.notified());
+
+  // Opacity changes should alert the observers.
+  observer.Reset();
+  l2->SetOpacity(0.5f);
+  RunPendingMessages();
+  EXPECT_TRUE(observer.notified());
+
+  // So should setting the opacity back.
+  observer.Reset();
+  l2->SetOpacity(1.0f);
+  RunPendingMessages();
+  EXPECT_TRUE(observer.notified());
+
+  // Setting the transform of a layer should alert the observers.
+  observer.Reset();
+  Transform transform;
+  transform.ConcatTranslate(-200, -200);
+  transform.ConcatRotate(90.0f);
+  transform.ConcatTranslate(200, 200);
+  l2->SetTransform(transform);
+  RunPendingMessages();
+  EXPECT_TRUE(observer.notified());
+
+  GetCompositor()->RemoveObserver(&observer);
+
+  // Opacity changes should no longer alert the removed observer.
+  observer.Reset();
+  l2->SetOpacity(0.5f);
+  RunPendingMessages();
+  EXPECT_FALSE(observer.notified());
+}
+
 } // namespace ui