Clean up compositor initialization/destruction.

ui/compositor/layer_unittest.cc

 // Copyright (c) 2012 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/bind.h"
 #include "base/compiler_specific.h"
 #include "base/file_util.h"
 #include "base/files/file_path.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/path_service.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "cc/layers/layer.h"
 #include "cc/output/delegated_frame_data.h"
 #include "cc/test/pixel_test_utils.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/compositor/compositor_observer.h"
-#include "ui/compositor/compositor_setup.h"
 #include "ui/compositor/layer.h"
 #include "ui/compositor/layer_animation_sequence.h"
 #include "ui/compositor/layer_animator.h"
 #include "ui/compositor/test/test_compositor_host.h"
 #include "ui/compositor/test/test_layers.h"
 #include "ui/gfx/canvas.h"
 #include "ui/gfx/codec/png_codec.h"
 #include "ui/gfx/gfx_paths.h"
 #include "ui/gfx/skia_util.h"
 
@@ skipping 44 matching lines @@
     if (PathService::Get(gfx::DIR_TEST_DATA, &test_data_directory_)) {
       test_data_directory_ = test_data_directory_.AppendASCII("compositor");
     } else {
       LOG(ERROR) << "Could not open test data directory.";
     }
   }
   virtual ~LayerWithRealCompositorTest() {}
 
   // Overridden from testing::Test:
   virtual void SetUp() OVERRIDE {
-    DisableTestCompositor();
+    bool allow_test_contexts = false;
+    Compositor::InitializeContextFactoryForTests(allow_test_contexts);
+    Compositor::Initialize();
+
     const gfx::Rect host_bounds(10, 10, 500, 500);
     window_.reset(TestCompositorHost::Create(host_bounds));
     window_->Show();
   }
 
   virtual void TearDown() OVERRIDE {
+    window_.reset();
+    Compositor::Terminate();
   }
 
   Compositor* GetCompositor() {
     return window_->GetCompositor();
   }
 
   Layer* CreateLayer(LayerType type) {
     return new Layer(type);
   }
 
@@ skipping 198 matching lines @@
   bool committed_;
   bool started_;
   bool ended_;
   bool aborted_;
 
   DISALLOW_COPY_AND_ASSIGN(TestCompositorObserver);
 };
 
 }  // namespace
 
-#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
-#define MAYBE_CompositorObservers DISABLED_CompositorObservers
-#define MAYBE_ModifyHierarchy DISABLED_ModifyHierarchy
-#define MAYBE_Opacity DISABLED_Opacity
-#define MAYBE_ScaleUpDown DISABLED_ScaleUpDown
-#define MAYBE_ScaleReparent DISABLED_ScaleReparent
-#define MAYBE_NoScaleCanvas DISABLED_NoScaleCanvas
-#define MAYBE_AddRemoveThreadedAnimations DISABLED_AddRemoveThreadedAnimations
-#define MAYBE_SwitchCCLayerAnimations DISABLED_SwitchCCLayerAnimations
-#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
-#define MAYBE_CompositorObservers CompositorObservers
-#define MAYBE_ModifyHierarchy ModifyHierarchy
-#define MAYBE_Opacity Opacity
-#define MAYBE_ScaleUpDown ScaleUpDown
-#define MAYBE_ScaleReparent ScaleReparent
-#define MAYBE_NoScaleCanvas NoScaleCanvas
-#define MAYBE_AddRemoveThreadedAnimations AddRemoveThreadedAnimations
-#define MAYBE_SwitchCCLayerAnimations SwitchCCLayerAnimations
-#endif
-
-TEST_F(LayerWithRealCompositorTest, MAYBE_Draw) {
+TEST_F(LayerWithRealCompositorTest, Draw) {
   scoped_ptr<Layer> layer(CreateColorLayer(SK_ColorRED,
                                            gfx::Rect(20, 20, 50, 50)));
   DrawTree(layer.get());
 }
 
 // Create this hierarchy:
 // L1 - red
 // +-- L2 - blue
 // |   +-- L3 - yellow
 // +-- L4 - magenta
 //
-TEST_F(LayerWithRealCompositorTest, MAYBE_Hierarchy) {
+TEST_F(LayerWithRealCompositorTest, Hierarchy) {
   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)));
   scoped_ptr<Layer> l3(CreateColorLayer(SK_ColorYELLOW,
                                         gfx::Rect(5, 5, 25, 25)));
   scoped_ptr<Layer> l4(CreateColorLayer(SK_ColorMAGENTA,
                                         gfx::Rect(300, 300, 100, 100)));
 
   l1->Add(l2.get());
   l1->Add(l4.get());
   l2->Add(l3.get());
 
   DrawTree(l1.get());
 }
 
 class LayerWithDelegateTest : public testing::Test, public CompositorDelegate {
  public:
   LayerWithDelegateTest() {}
   virtual ~LayerWithDelegateTest() {}
 
   // Overridden from testing::Test:
   virtual void SetUp() OVERRIDE {
-    ui::SetupTestCompositor();
+    bool allow_test_contexts = true;
+    Compositor::InitializeContextFactoryForTests(allow_test_contexts);
+    Compositor::Initialize();
     compositor_.reset(new Compositor(this, gfx::kNullAcceleratedWidget));
     compositor_->SetScaleAndSize(1.0f, gfx::Size(1000, 1000));
   }
 
   virtual void TearDown() OVERRIDE {
+    compositor_.reset();
+    Compositor::Terminate();
   }
 
   Compositor* compositor() { return compositor_.get(); }
 
   virtual Layer* CreateLayer(LayerType type) {
     return new Layer(type);
   }
 
   Layer* CreateColorLayer(SkColor color, const gfx::Rect& bounds) {
     Layer* layer = new ColoredLayer(color);
@@ skipping 86 matching lines @@
   Layer::ConvertPointToLayer(l3.get(), l1.get(), &point1_in_l3_coords);
   gfx::Point point1_in_l1_coords(25, 25);
   EXPECT_EQ(point1_in_l1_coords, point1_in_l3_coords);
 
   gfx::Point point2_in_l1_coords(5, 5);
   Layer::ConvertPointToLayer(l1.get(), l3.get(), &point2_in_l1_coords);
   gfx::Point point2_in_l3_coords(-15, -15);
   EXPECT_EQ(point2_in_l3_coords, point2_in_l1_coords);
 }
 
-TEST_F(LayerWithRealCompositorTest, MAYBE_Delegate) {
+TEST_F(LayerWithRealCompositorTest, Delegate) {
   scoped_ptr<Layer> l1(CreateColorLayer(SK_ColorBLACK,
                                         gfx::Rect(20, 20, 400, 400)));
   GetCompositor()->SetRootLayer(l1.get());
   WaitForDraw();
 
   TestLayerDelegate delegate;
   l1->set_delegate(&delegate);
   delegate.AddColor(SK_ColorWHITE);
   delegate.AddColor(SK_ColorYELLOW);
   delegate.AddColor(SK_ColorGREEN);
 
   l1->SchedulePaint(gfx::Rect(0, 0, 400, 400));
   WaitForDraw();
 
   EXPECT_EQ(delegate.color_index(), 1);
   EXPECT_EQ(delegate.paint_size(), l1->bounds().size());
 
   l1->SchedulePaint(gfx::Rect(10, 10, 200, 200));
   WaitForDraw();
   EXPECT_EQ(delegate.color_index(), 2);
   EXPECT_EQ(delegate.paint_size(), gfx::Size(200, 200));
 
   l1->SchedulePaint(gfx::Rect(5, 5, 50, 50));
   WaitForDraw();
   EXPECT_EQ(delegate.color_index(), 0);
   EXPECT_EQ(delegate.paint_size(), gfx::Size(50, 50));
 }
 
-TEST_F(LayerWithRealCompositorTest, MAYBE_DrawTree) {
+TEST_F(LayerWithRealCompositorTest, DrawTree) {
   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)));
   scoped_ptr<Layer> l3(CreateColorLayer(SK_ColorYELLOW,
                                         gfx::Rect(10, 10, 100, 100)));
   l1->Add(l2.get());
   l2->Add(l3.get());
 
   GetCompositor()->SetRootLayer(l1.get());
@@ skipping 13 matching lines @@
   EXPECT_FALSE(d3.painted());
 }
 
 // Tests no-texture Layers.
 // Create this hierarchy:
 // L1 - red
 // +-- L2 - NO TEXTURE
 // |   +-- L3 - yellow
 // +-- L4 - magenta
 //
-TEST_F(LayerWithRealCompositorTest, MAYBE_HierarchyNoTexture) {
+TEST_F(LayerWithRealCompositorTest, HierarchyNoTexture) {
   scoped_ptr<Layer> l1(CreateColorLayer(SK_ColorRED,
                                         gfx::Rect(20, 20, 400, 400)));
   scoped_ptr<Layer> l2(CreateNoTextureLayer(gfx::Rect(10, 10, 350, 350)));
   scoped_ptr<Layer> l3(CreateColorLayer(SK_ColorYELLOW,
                                         gfx::Rect(5, 5, 25, 25)));
   scoped_ptr<Layer> l4(CreateColorLayer(SK_ColorMAGENTA,
                                         gfx::Rect(300, 300, 100, 100)));
 
   l1->Add(l2.get());
   l1->Add(l4.get());
@@ skipping 15 matching lines @@
   EXPECT_FALSE(d2.painted());
   // |d3| should have received a paint notification.
   EXPECT_TRUE(d3.painted());
 }
 
 class LayerWithNullDelegateTest : public LayerWithDelegateTest {
  public:
   LayerWithNullDelegateTest() {}
   virtual ~LayerWithNullDelegateTest() {}
 
-  // Overridden from testing::Test:
   virtual void SetUp() OVERRIDE {
     LayerWithDelegateTest::SetUp();
     default_layer_delegate_.reset(new NullLayerDelegate());
   }
 
-  virtual void TearDown() OVERRIDE {
-  }
-
   virtual Layer* CreateLayer(LayerType type) OVERRIDE {
     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 182 matching lines @@
   // The CompositorDelegate (us) should have been told to draw for a move.
   WaitForDraw();
 
   l1->SetBounds(gfx::Rect(5, 5, 100, 100));
 
   // The CompositorDelegate (us) should have been told to draw for a resize.
   WaitForDraw();
 }
 
 // Checks that pixels are actually drawn to the screen with a read back.
-// Currently disabled on all platforms, see http://crbug.com/148709.
-TEST_F(LayerWithRealCompositorTest, MAYBE_DrawPixels) {
-  scoped_ptr<Layer> layer(CreateColorLayer(SK_ColorRED,
-                                           gfx::Rect(0, 0, 500, 500)));
-  scoped_ptr<Layer> layer2(CreateColorLayer(SK_ColorBLUE,
-                                            gfx::Rect(0, 0, 500, 10)));
+TEST_F(LayerWithRealCompositorTest, DrawPixels) {
+  gfx::Size viewport_size = GetCompositor()->size();
+
+  // The window should be some non-trivial size but may not be exactly
+  // 500x500 on all platforms/bots.
+  EXPECT_GE(viewport_size.width(), 200);
+  EXPECT_GE(viewport_size.height(), 200);
+
+  int blue_height = 10;
+
+  scoped_ptr<Layer> layer(
+      CreateColorLayer(SK_ColorRED, gfx::Rect(viewport_size)));
+  scoped_ptr<Layer> layer2(
+      CreateColorLayer(SK_ColorBLUE,
+                       gfx::Rect(0, 0, viewport_size.width(), blue_height)));
 
   layer->Add(layer2.get());
 
   DrawTree(layer.get());
 
   SkBitmap bitmap;
-  gfx::Size size = GetCompositor()->size();
-  ASSERT_TRUE(GetCompositor()->ReadPixels(&bitmap,
-                                          gfx::Rect(0, 10,
-                                          size.width(), size.height() - 10)));
+  ASSERT_TRUE(GetCompositor()->ReadPixels(&bitmap, gfx::Rect(viewport_size)));
   ASSERT_FALSE(bitmap.empty());
 
   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 < 490; y++)
-      is_all_red = is_all_red && (bitmap.getColor(x, y) == SK_ColorRED);
-
-  EXPECT_TRUE(is_all_red);
+  for (int x = 0; x < viewport_size.width(); x++) {
+    for (int y = 0; y < viewport_size.height(); y++) {
+      SkColor actual_color = bitmap.getColor(x, y);
+      SkColor expected_color = y < blue_height ? SK_ColorBLUE : SK_ColorRED;
+      EXPECT_EQ(expected_color, actual_color)
+          << "Pixel error at x=" << x << " y=" << y << "; "
+          << "actual RGBA=("
+          << SkColorGetR(actual_color) << ","
+          << SkColorGetG(actual_color) << ","
+          << SkColorGetB(actual_color) << ","
+          << SkColorGetA(actual_color) << "); "
+          << "expected RGBA=("
+          << SkColorGetR(expected_color) << ","
+          << SkColorGetG(expected_color) << ","
+          << SkColorGetB(expected_color) << ","
+          << SkColorGetA(expected_color) << ")";
+    }
+  }
 }
 
 // Checks the logic around Compositor::SetRootLayer and Layer::SetCompositor.
-TEST_F(LayerWithRealCompositorTest, MAYBE_SetRootLayer) {
+TEST_F(LayerWithRealCompositorTest, SetRootLayer) {
   Compositor* compositor = GetCompositor();
   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)));
 
   EXPECT_EQ(NULL, l1->GetCompositor());
   EXPECT_EQ(NULL, l2->GetCompositor());
 
   compositor->SetRootLayer(l1.get());
@@ skipping 11 matching lines @@
   compositor->SetRootLayer(NULL);
   EXPECT_EQ(NULL, l1->GetCompositor());
   EXPECT_EQ(NULL, l2->GetCompositor());
 }
 
 // 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) {
+TEST_F(LayerWithRealCompositorTest, 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.
@@ skipping 53 matching lines @@
 
   // Opacity changes should no longer alert the removed observer.
   observer.Reset();
   l2->SetOpacity(0.5f);
   WaitForDraw();
 
   EXPECT_FALSE(observer.notified());
 }
 
 // Checks that modifying the hierarchy correctly affects final composite.
-TEST_F(LayerWithRealCompositorTest, MAYBE_ModifyHierarchy) {
+TEST_F(LayerWithRealCompositorTest, ModifyHierarchy) {
   GetCompositor()->SetScaleAndSize(1.0f, gfx::Size(50, 50));
 
   // l0
   //  +-l11
   //  | +-l21
   //  +-l12
   scoped_ptr<Layer> l0(CreateColorLayer(SK_ColorRED,
                                         gfx::Rect(0, 0, 50, 50)));
   scoped_ptr<Layer> l11(CreateColorLayer(SK_ColorGREEN,
                                          gfx::Rect(0, 0, 25, 25)));
@@ skipping 48 matching lines @@
   // l11 back to front
   l0->StackAbove(l11.get(), l12.get());
   DrawTree(l0.get());
   ASSERT_TRUE(ReadPixels(&bitmap));
   ASSERT_FALSE(bitmap.empty());
   EXPECT_TRUE(MatchesPNGFile(bitmap, ref_img2, cc::ExactPixelComparator(true)));
 }
 
 // Opacity is rendered correctly.
 // Checks that modifying the hierarchy correctly affects final composite.
-TEST_F(LayerWithRealCompositorTest, MAYBE_Opacity) {
+TEST_F(LayerWithRealCompositorTest, Opacity) {
   GetCompositor()->SetScaleAndSize(1.0f, gfx::Size(50, 50));
 
   // l0
   //  +-l11
   scoped_ptr<Layer> l0(CreateColorLayer(SK_ColorRED,
                                         gfx::Rect(0, 0, 50, 50)));
   scoped_ptr<Layer> l11(CreateColorLayer(SK_ColorGREEN,
                                          gfx::Rect(0, 0, 25, 25)));
 
   base::FilePath ref_img = test_data_directory().AppendASCII("Opacity.png");
@@ skipping 87 matching lines @@
   EXPECT_EQ(1, child_delegate.GetPaintCountAndClear());
 
   // Because SchedulePaint() was invoked from OnPaintLayer() |child| should
   // still need to be painted.
   WaitForCommit();
   EXPECT_EQ(1, child_delegate.GetPaintCountAndClear());
   EXPECT_TRUE(child_delegate.last_clip_rect().Contains(
                   gfx::Rect(10, 10, 30, 30)));
 }
 
-TEST_F(LayerWithRealCompositorTest, MAYBE_ScaleUpDown) {
+TEST_F(LayerWithRealCompositorTest, ScaleUpDown) {
   scoped_ptr<Layer> root(CreateColorLayer(SK_ColorWHITE,
                                           gfx::Rect(10, 20, 200, 220)));
   TestLayerDelegate root_delegate;
   root_delegate.AddColor(SK_ColorWHITE);
   root->set_delegate(&root_delegate);
 
   scoped_ptr<Layer> l1(CreateColorLayer(SK_ColorWHITE,
                                         gfx::Rect(10, 20, 140, 180)));
   TestLayerDelegate l1_delegate;
   l1_delegate.AddColor(SK_ColorWHITE);
@@ skipping 65 matching lines @@
   // No scale change, so no scale notification.
   EXPECT_EQ(0.0f, root_delegate.device_scale_factor());
   EXPECT_EQ(0.0f, l1_delegate.device_scale_factor());
   WaitForDraw();
   EXPECT_EQ("0x0", root_delegate.paint_size().ToString());
   EXPECT_EQ("0.0 0.0", root_delegate.ToScaleString());
   EXPECT_EQ("0x0", l1_delegate.paint_size().ToString());
   EXPECT_EQ("0.0 0.0", l1_delegate.ToScaleString());
 }
 
-TEST_F(LayerWithRealCompositorTest, MAYBE_ScaleReparent) {
+TEST_F(LayerWithRealCompositorTest, ScaleReparent) {
   scoped_ptr<Layer> root(CreateColorLayer(SK_ColorWHITE,
                                           gfx::Rect(10, 20, 200, 220)));
   scoped_ptr<Layer> l1(CreateColorLayer(SK_ColorWHITE,
                                         gfx::Rect(10, 20, 140, 180)));
   TestLayerDelegate l1_delegate;
   l1_delegate.AddColor(SK_ColorWHITE);
   l1->set_delegate(&l1_delegate);
 
   GetCompositor()->SetScaleAndSize(1.0f, gfx::Size(500, 500));
   GetCompositor()->SetRootLayer(root.get());
@@ skipping 24 matching lines @@
   EXPECT_EQ("10,20 140x180", l1->bounds().ToString());
   size_in_pixel = l1->cc_layer()->bounds();
   EXPECT_EQ("280x360", size_in_pixel.ToString());
   EXPECT_EQ(2.0f, l1_delegate.device_scale_factor());
   WaitForDraw();
   EXPECT_EQ("280x360", l1_delegate.paint_size().ToString());
   EXPECT_EQ("2.0 2.0", l1_delegate.ToScaleString());
 }
 
 // Tests layer::set_scale_content(false).
-TEST_F(LayerWithRealCompositorTest, MAYBE_NoScaleCanvas) {
+TEST_F(LayerWithRealCompositorTest, NoScaleCanvas) {
   scoped_ptr<Layer> root(CreateColorLayer(SK_ColorWHITE,
                                           gfx::Rect(10, 20, 200, 220)));
   scoped_ptr<Layer> l1(CreateColorLayer(SK_ColorWHITE,
                                         gfx::Rect(10, 20, 140, 180)));
   l1->set_scale_content(false);
   root->Add(l1.get());
   TestLayerDelegate l1_delegate;
   l1_delegate.AddColor(SK_ColorWHITE);
   l1->set_delegate(&l1_delegate);
 
@@ skipping 94 matching lines @@
   EXPECT_EQ(child->cc_layer()->bounds().ToString(),
             gfx::Size(20, 20).ToString());
 
   // Low-DPI content on hi-DPI layer.
   child->SetDelegatedFrame(MakeFrameData(gfx::Size(10, 10)), gfx::Size(10, 10));
   EXPECT_EQ(child->cc_layer()->bounds().ToString(),
             gfx::Size(20, 20).ToString());
 }
 
 // Tests Layer::AddThreadedAnimation and Layer::RemoveThreadedAnimation.
-TEST_F(LayerWithRealCompositorTest, MAYBE_AddRemoveThreadedAnimations) {
+TEST_F(LayerWithRealCompositorTest, AddRemoveThreadedAnimations) {
   scoped_ptr<Layer> root(CreateLayer(LAYER_TEXTURED));
   scoped_ptr<Layer> l1(CreateLayer(LAYER_TEXTURED));
   scoped_ptr<Layer> l2(CreateLayer(LAYER_TEXTURED));
 
   l1->SetAnimator(LayerAnimator::CreateImplicitAnimator());
   l2->SetAnimator(LayerAnimator::CreateImplicitAnimator());
 
   EXPECT_FALSE(l1->HasPendingThreadedAnimations());
 
   // Trigger a threaded animation.
@@ skipping 26 matching lines @@
   // animations to get dispatched.
   l2->SetOpacity(0.5f);
   EXPECT_TRUE(l2->HasPendingThreadedAnimations());
 
   l1->Add(l2.get());
   EXPECT_FALSE(l2->HasPendingThreadedAnimations());
 }
 
 // Tests that in-progress threaded animations complete when a Layer's
 // cc::Layer changes.
-TEST_F(LayerWithRealCompositorTest, MAYBE_SwitchCCLayerAnimations) {
+TEST_F(LayerWithRealCompositorTest, SwitchCCLayerAnimations) {
   scoped_ptr<Layer> root(CreateLayer(LAYER_TEXTURED));
   scoped_ptr<Layer> l1(CreateLayer(LAYER_TEXTURED));
   GetCompositor()->SetRootLayer(root.get());
   root->Add(l1.get());
 
   l1->SetAnimator(LayerAnimator::CreateImplicitAnimator());
 
   EXPECT_FLOAT_EQ(l1->opacity(), 1.0f);
 
   // Trigger a threaded animation.
   l1->SetOpacity(0.5f);
 
   // Change l1's cc::Layer.
   l1->SwitchCCLayerForTest();
 
   // Ensure that the opacity animation completed.
   EXPECT_FLOAT_EQ(l1->opacity(), 0.5f);
 }
 
 }  // namespace ui