Fold views_compositor=1 into use_aura=1

ui/views/view_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 <map>
 
 #include "base/memory/scoped_ptr.h"
 #include "base/rand_util.h"
 #include "base/string_util.h"
 #include "base/utf_string_conversions.h"
@@ skipping 2518 matching lines @@
   EXPECT_EQ(1, v1.GetIndexOf(&v3));
   v1.AddChildView(&v3);
   EXPECT_EQ(0, v1.GetIndexOf(&v2));
   EXPECT_EQ(1, v1.GetIndexOf(&v3));
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // Layers
 ////////////////////////////////////////////////////////////////////////////////
 
-#if defined(VIEWS_COMPOSITOR)
+#if defined(USE_AURA)
 
 namespace {
 
 // Test implementation of LayerAnimator.
 class TestLayerAnimator : public ui::LayerAnimator {
  public:
   TestLayerAnimator();
 
   const gfx::Rect& last_bounds() const { return last_bounds_; }
 
@@ skipping 18 matching lines @@
 
 class ViewLayerTest : public ViewsTestBase {
  public:
   ViewLayerTest() : widget_(NULL), old_use_acceleration_(false) {}
 
   virtual ~ViewLayerTest() {
   }
 
   // Returns the Layer used by the RootView.
   ui::Layer* GetRootLayer() {
-#if defined(USE_AURA)
     ui::Layer* root_layer = NULL;
     gfx::Point origin;
     widget()->CalculateOffsetToAncestorWithLayer(&origin, &root_layer);
     return root_layer;
-#else
-    return widget()->GetRootView()->layer();
-#endif
   }
 
   virtual void SetUp() OVERRIDE {
     ViewTest::SetUp();
     old_use_acceleration_ = View::get_use_acceleration_when_possible();
     View::set_use_acceleration_when_possible(true);
 
     widget_ = new Widget;
     Widget::InitParams params(Widget::InitParams::TYPE_POPUP);
     params.bounds = gfx::Rect(50, 50, 200, 200);
     widget_->Init(params);
     widget_->Show();
     widget_->GetRootView()->SetBounds(0, 0, 200, 200);
   }
 
   virtual void TearDown() OVERRIDE {
     View::set_use_acceleration_when_possible(old_use_acceleration_);
     widget_->CloseNow();
     Widget::SetPureViews(false);
     ViewsTestBase::TearDown();
   }
 
   Widget* widget() { return widget_; }
 
  private:
   Widget* widget_;
   bool old_use_acceleration_;
 };
 
-#if !defined(USE_AURA)
-// This test assumes a particular layer hierarchy that isn't valid for aura.
-// Ensures the RootView has a layer and its set up correctly.
-TEST_F(ViewLayerTest, RootState) {
-  ui::Layer* layer = widget()->GetRootView()->layer();
-  ASSERT_TRUE(layer);
-  EXPECT_FALSE(layer->parent());
-  EXPECT_EQ(0u, layer->children().size());
-  EXPECT_FALSE(layer->transform().HasChange());
-  EXPECT_EQ(widget()->GetRootView()->bounds(), layer->bounds());
-  EXPECT_TRUE(layer->GetCompositor() != NULL);
-}
-
-// Verifies that the complete bounds of a texture are updated if the texture
-// needs to be refreshed and paint with a clip is invoked.
-// This test invokes OnNativeWidgetPaintAccelerated, which is not used by aura.
-TEST_F(ViewLayerTest, PaintAll) {
-  View* view = widget()->GetRootView();
-  ui::Layer* layer = GetRootLayer();
-  view->SetBounds(0, 0, 200, 200);
-  widget()->OnNativeWidgetPaintAccelerated(gfx::Rect(0, 0, 1, 1));
-  ASSERT_TRUE(layer != NULL);
-  const ui::TestTexture* texture =
-      static_cast<const ui::TestTexture*>(layer->texture());
-  ASSERT_TRUE(texture != NULL);
-  EXPECT_EQ(view->GetLocalBounds(), texture->bounds_of_last_paint());
-}
-#endif
 
 TEST_F(ViewLayerTest, LayerToggling) {
   // Because we lazily create textures the calls to DrawTree are necessary to
   // ensure we trigger creation of textures.
-#if defined(USE_AURA)
   ui::Layer* root_layer = NULL;
   gfx::Point origin;
   widget()->CalculateOffsetToAncestorWithLayer(&origin, &root_layer);
-#else
-  ui::Layer* root_layer = widget()->GetRootView()->layer();
-#endif
   View* content_view = new View;
   widget()->SetContentsView(content_view);
 
   // Create v1, give it a bounds and verify everything is set up correctly.
   View* v1 = new View;
   v1->SetPaintToLayer(true);
   EXPECT_TRUE(v1->layer() != NULL);
   v1->SetBounds(20, 30, 140, 150);
   content_view->AddChildView(v1);
   ASSERT_TRUE(v1->layer() != NULL);
@@ skipping 311 matching lines @@
   ScrambleTree(content);
   EXPECT_TRUE(ViewAndLayerTreeAreConsistent(content, content->layer()));
 
   ScrambleTree(content);
   EXPECT_TRUE(ViewAndLayerTreeAreConsistent(content, content->layer()));
 
   ScrambleTree(content);
   EXPECT_TRUE(ViewAndLayerTreeAreConsistent(content, content->layer()));
 }
 
-#if defined(USE_AURA)
 // Verifies when views are reordered the layer is also reordered. The widget is
 // providing the parent layer.
 TEST_F(ViewLayerTest, ReorderUnderWidget) {
   View* content = new View;
   widget()->SetContentsView(content);
   View* c1 = new View;
   c1->SetPaintToLayer(true);
   content->AddChildView(c1);
   View* c2 = new View;
   c2->SetPaintToLayer(true);
   content->AddChildView(c2);
 
   ui::Layer* parent_layer = c1->layer()->parent();
   ASSERT_TRUE(parent_layer);
   ASSERT_EQ(2u, parent_layer->children().size());
   EXPECT_EQ(c1->layer(), parent_layer->children()[0]);
   EXPECT_EQ(c2->layer(), parent_layer->children()[1]);
 
   // Move c1 to the front. The layers should have moved too.
   content->ReorderChildView(c1, -1);
   EXPECT_EQ(c1->layer(), parent_layer->children()[1]);
   EXPECT_EQ(c2->layer(), parent_layer->children()[0]);
 }
-#endif
 
-#endif  // VIEWS_COMPOSITOR
+#endif  // USE_AURA
 
 }  // namespace views