Remove ::create factory functions from objects created via WebCompositorSupport

webkit/compositor_bindings/web_layer_unittest.cc

 // Copyright 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 <public/WebLayer.h>
 
 #include "cc/thread.h"
 #include "cc/test/compositor_fake_web_graphics_context_3d.h"
-#include "web_layer_impl.h"
-#include "web_layer_tree_view_impl.h"
-#include "web_layer_tree_view_test_common.h"
+#include "webkit/compositor_bindings/test/web_layer_tree_view_test_common.h"
+#include "webkit/compositor_bindings/web_layer_impl.h"
+#include "webkit/compositor_bindings/web_layer_tree_view_impl.h"
+#include "webkit/compositor_bindings/web_content_layer_impl.h"
+#include "webkit/compositor_bindings/web_solid_color_layer_impl.h"
+#include "webkit/compositor_bindings/web_external_texture_layer_impl.h"
 #include <public/WebContentLayer.h>
 #include <public/WebContentLayerClient.h>
 #include <public/WebExternalTextureLayer.h>
 #include <public/WebFloatPoint.h>
 #include <public/WebFloatRect.h>
 #include <public/WebLayerScrollClient.h>
 #include <public/WebLayerTreeView.h>
 #include <public/WebLayerTreeViewClient.h>
 #include <public/WebRect.h>
 #include <public/WebSize.h>
@@ skipping 20 matching lines @@
 };
 
 class WebLayerTest : public Test {
 public:
     WebLayerTest()
     {
     }
 
     virtual void SetUp()
     {
-        m_rootLayer.reset(WebLayer::create());
+        m_rootLayer.reset(new WebLayerImpl);
         EXPECT_CALL(m_client, scheduleComposite()).Times(AnyNumber());
         m_view.reset(new WebLayerTreeViewImpl(&m_client));
         EXPECT_TRUE(m_view->initialize(WebLayerTreeView::Settings(), scoped_ptr<cc::Thread>(NULL)));
         m_view->setRootLayer(*m_rootLayer);
         EXPECT_TRUE(m_view);
         Mock::VerifyAndClearExpectations(&m_client);
     }
 
     virtual void TearDown()
     {
         // We may get any number of scheduleComposite calls during shutdown.
         EXPECT_CALL(m_client, scheduleComposite()).Times(AnyNumber());
         m_rootLayer.reset();
         m_view.reset();
     }
 
 protected:
     MockWebLayerTreeViewClient m_client;
-    scoped_ptr<WebLayer> m_rootLayer;
+    scoped_ptr<WebLayerImpl> m_rootLayer;
     scoped_ptr<WebLayerTreeViewImpl> m_view;
 };
 
 // Tests that the client gets called to ask for a composite if we change the
 // fields.
 TEST_F(WebLayerTest, Client)
 {
     // Base layer.
     EXPECT_CALL(m_client, scheduleComposite()).Times(AnyNumber());
-    scoped_ptr<WebLayer> layer(WebLayer::create());
+    scoped_ptr<WebLayer> layer(new WebLayerImpl);
     layer->setDrawsContent(true);
     m_rootLayer->addChild(layer.get());
     Mock::VerifyAndClearExpectations(&m_client);
 
     WebFloatPoint point(3, 4);
     EXPECT_CALL(m_client, scheduleComposite()).Times(AtLeast(1));
     layer->setAnchorPoint(point);
     Mock::VerifyAndClearExpectations(&m_client);
     EXPECT_EQ(point, layer->anchorPoint());
 
     EXPECT_CALL(m_client, scheduleComposite()).Times(AtLeast(1));
     float anchorZ = 5;
     layer->setAnchorPointZ(anchorZ);
     Mock::VerifyAndClearExpectations(&m_client);
     EXPECT_EQ(anchorZ, layer->anchorPointZ());
 
     WebSize size(7, 8);
     EXPECT_CALL(m_client, scheduleComposite()).Times(AtLeast(1));
     layer->setBounds(size);
     Mock::VerifyAndClearExpectations(&m_client);
     EXPECT_EQ(size, layer->bounds());
 
     EXPECT_CALL(m_client, scheduleComposite()).Times(AtLeast(1));
     layer->setMasksToBounds(true);
     Mock::VerifyAndClearExpectations(&m_client);
     EXPECT_TRUE(layer->masksToBounds());
 
     EXPECT_CALL(m_client, scheduleComposite()).Times(AnyNumber());
-    scoped_ptr<WebLayer> otherLayer(WebLayer::create());
+    scoped_ptr<WebLayer> otherLayer(new WebLayerImpl);
     m_rootLayer->addChild(otherLayer.get());
     EXPECT_CALL(m_client, scheduleComposite()).Times(AtLeast(1));
     layer->setMaskLayer(otherLayer.get());
     Mock::VerifyAndClearExpectations(&m_client);
 
     EXPECT_CALL(m_client, scheduleComposite()).Times(AtLeast(1));
     float opacity = 0.123f;
     layer->setOpacity(opacity);
     Mock::VerifyAndClearExpectations(&m_client);
     EXPECT_EQ(opacity, layer->opacity());
 
     EXPECT_CALL(m_client, scheduleComposite()).Times(AtLeast(1));
     layer->setOpaque(true);
     Mock::VerifyAndClearExpectations(&m_client);
     EXPECT_TRUE(layer->opaque());
 
     EXPECT_CALL(m_client, scheduleComposite()).Times(AtLeast(1));
     layer->setPosition(point);
     Mock::VerifyAndClearExpectations(&m_client);
     EXPECT_EQ(point, layer->position());
 
     // Texture layer.
     EXPECT_CALL(m_client, scheduleComposite()).Times(AtLeast(1));
-    scoped_ptr<WebExternalTextureLayer> textureLayer(WebExternalTextureLayer::create());
+    scoped_ptr<WebExternalTextureLayer> textureLayer(new WebExternalTextureLayerImpl(NULL));
     m_rootLayer->addChild(textureLayer->layer());
     Mock::VerifyAndClearExpectations(&m_client);
 
     EXPECT_CALL(m_client, scheduleComposite()).Times(AtLeast(1));
     textureLayer->setTextureId(3);
     Mock::VerifyAndClearExpectations(&m_client);
 
     EXPECT_CALL(m_client, scheduleComposite()).Times(AtLeast(1));
     textureLayer->setFlipped(true);
     Mock::VerifyAndClearExpectations(&m_client);
 
     EXPECT_CALL(m_client, scheduleComposite()).Times(AtLeast(1));
     WebFloatRect uvRect(0.1f, 0.1f, 0.9f, 0.9f);
     textureLayer->setUVRect(uvRect);
     Mock::VerifyAndClearExpectations(&m_client);
 
 
     // Content layer.
     MockWebContentLayerClient contentClient;
 #if WEBCONTENTLAYERCLIENT_HAS_CANPAINTLCDTEXT
     EXPECT_CALL(contentClient, paintContents(_, _, _, _)).Times(AnyNumber());
 #else
     EXPECT_CALL(contentClient, paintContents(_, _, _)).Times(AnyNumber());
 #endif  // WEBCONTENTLAYERCLIENT_HAS_CANPAINTLCDTEXT
                                              
     EXPECT_CALL(m_client, scheduleComposite()).Times(AnyNumber());
-    scoped_ptr<WebContentLayer> contentLayer(WebContentLayer::create(&contentClient));
+    scoped_ptr<WebContentLayer> contentLayer(new WebContentLayerImpl(&contentClient));
     m_rootLayer->addChild(contentLayer->layer());
     Mock::VerifyAndClearExpectations(&m_client);
 
     EXPECT_CALL(m_client, scheduleComposite()).Times(AtLeast(1));
     contentLayer->layer()->setDrawsContent(false);
     Mock::VerifyAndClearExpectations(&m_client);
     EXPECT_FALSE(contentLayer->layer()->drawsContent());
 
     // Solid color layer.
     EXPECT_CALL(m_client, scheduleComposite()).Times(AtLeast(1));
-    scoped_ptr<WebSolidColorLayer> solidColorLayer(WebSolidColorLayer::create());
+    scoped_ptr<WebSolidColorLayer> solidColorLayer(new WebSolidColorLayerImpl);
     m_rootLayer->addChild(solidColorLayer->layer());
     Mock::VerifyAndClearExpectations(&m_client);
 
 }
 
 class MockScrollClient : public WebLayerScrollClient {
 public:
     MOCK_METHOD0(didScroll, void());
 };
 
@@ skipping 10 matching lines @@
     Mock::VerifyAndClearExpectations(&scrollClient);
 
     EXPECT_CALL(scrollClient, didScroll()).Times(0);
     m_rootLayer->setScrollPosition(WebPoint(14, 19));
     Mock::VerifyAndClearExpectations(&scrollClient);
 
     m_rootLayer->setScrollClient(0);
 }
 
 }