Implement WebKit::WebUnitTestSupport::createLayerTreeViewForTesting()

cc/layer_tree_host_unittest_context.cc

 // Copyright 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 "cc/layer_tree_host.h"
 
 #include "base/basictypes.h"
 #include "cc/content_layer.h"
 #include "cc/delegated_renderer_layer.h"
 #include "cc/delegated_renderer_layer_impl.h"
 #include "cc/heads_up_display_layer.h"
 #include "cc/io_surface_layer.h"
 #include "cc/layer_impl.h"
 #include "cc/layer_tree_host_impl.h"
 #include "cc/layer_tree_impl.h"
 #include "cc/picture_layer.h"
 #include "cc/scrollbar_layer.h"
 #include "cc/single_thread_proxy.h"
 #include "cc/test/fake_content_layer.h"
 #include "cc/test/fake_content_layer_client.h"
 #include "cc/test/fake_content_layer_impl.h"
 #include "cc/test/fake_output_surface.h"
 #include "cc/test/fake_scrollbar_layer.h"
 #include "cc/test/fake_scrollbar_theme_painter.h"
 #include "cc/test/fake_video_frame_provider.h"
-#include "cc/test/fake_web_graphics_context_3d.h"
 #include "cc/test/fake_web_scrollbar.h"
 #include "cc/test/fake_web_scrollbar_theme_geometry.h"
 #include "cc/test/layer_tree_test_common.h"
 #include "cc/test/render_pass_test_common.h"
+#include "cc/test/test_web_graphics_context_3d.h"
 #include "cc/texture_layer.h"
 #include "cc/video_layer.h"
 #include "cc/video_layer_impl.h"
 #include "gpu/GLES2/gl2extchromium.h"
 #include "media/base/media.h"
 
 using media::VideoFrame;
 using WebKit::WebGraphicsContext3D;
 
 namespace cc {
@@ skipping 15 matching lines @@
         times_to_lose_on_recreate_(0) {
     media::InitializeMediaLibraryForTesting();
   }
 
   void LoseContext() {
     context3d_->loseContextCHROMIUM(GL_GUILTY_CONTEXT_RESET_ARB,
                                     GL_INNOCENT_CONTEXT_RESET_ARB);
     context3d_ = NULL;
   }
 
-  virtual scoped_ptr<FakeWebGraphicsContext3D> CreateContext3d() {
-    return FakeWebGraphicsContext3D::Create();
+  virtual scoped_ptr<TestWebGraphicsContext3D> CreateContext3d() {
+    return TestWebGraphicsContext3D::Create();
   }
 
   virtual scoped_ptr<OutputSurface> createOutputSurface() OVERRIDE {
     if (times_to_fail_create_) {
       --times_to_fail_create_;
       return scoped_ptr<OutputSurface>();
     }
 
-    scoped_ptr<FakeWebGraphicsContext3D> context3d = CreateContext3d();
+    scoped_ptr<TestWebGraphicsContext3D> context3d = CreateContext3d();
     context3d_ = context3d.get();
 
     if (times_to_fail_initialize_) {
       --times_to_fail_initialize_;
       // Make the context get lost during reinitialization.
       // The number of times MakeCurrent succeeds is not important, and
       // can be changed if needed to make this pass with future changes.
       context3d_->set_times_make_current_succeeds(2);
     } else if (times_to_lose_on_create_) {
       --times_to_lose_on_create_;
@@ skipping 25 matching lines @@
 
     times_to_fail_create_ = times_to_fail_recreate_;
     times_to_fail_recreate_ = 0;
     times_to_fail_initialize_ = times_to_fail_reinitialize_;
     times_to_fail_reinitialize_ = 0;
     times_to_lose_on_create_ = times_to_lose_on_recreate_;
     times_to_lose_on_recreate_ = 0;
   }
 
  protected:
-  FakeWebGraphicsContext3D* context3d_;
+  TestWebGraphicsContext3D* context3d_;
   int times_to_fail_create_;
   int times_to_fail_initialize_;
   int times_to_lose_on_create_;
   int times_to_lose_during_commit_;
   int times_to_lose_during_draw_;
   int times_to_fail_reinitialize_;
   int times_to_fail_recreate_;
   int times_to_lose_on_recreate_;
 };
 
@@ skipping 164 matching lines @@
     // surface.  We want to make sure to test the drawing paths for drawing to
     // a child surface.
     content_->setNeedsDisplay();
     LayerTreeHostContextTestLostContextSucceeds::InvalidateAndSetNeedsCommit();
   }
 
   virtual void drawLayersOnThread(LayerTreeHostImpl* host_impl) OVERRIDE {
     FakeContentLayerImpl* content_impl = static_cast<FakeContentLayerImpl*>(
         host_impl->rootLayer()->children()[0]);
     // Even though the context was lost, we should have a resource. The
-    // FakeWebGraphicsContext3D ensures that this resource is created with
+    // TestWebGraphicsContext3D ensures that this resource is created with
     // the active context.
     EXPECT_TRUE(content_impl->HaveResourceForTileAt(0, 0));
   }
 
  protected:
   bool use_surface_;
   FakeContentLayerClient client_;
   scoped_refptr<Layer> root_;
   scoped_refptr<ContentLayer> content_;
 };
@@ skipping 224 matching lines @@
 
 class LayerTreeHostContextTestLostContextWhileUpdatingResources :
     public LayerTreeHostContextTest {
  public:
   LayerTreeHostContextTestLostContextWhileUpdatingResources()
       : parent_(FakeContentLayer::Create(&client_)),
         num_children_(50),
         times_to_lose_on_end_query_(3) {
   }
 
-  virtual scoped_ptr<FakeWebGraphicsContext3D> CreateContext3d() OVERRIDE {
-    scoped_ptr<FakeWebGraphicsContext3D> context =
+  virtual scoped_ptr<TestWebGraphicsContext3D> CreateContext3d() OVERRIDE {
+    scoped_ptr<TestWebGraphicsContext3D> context =
         LayerTreeHostContextTest::CreateContext3d();
     if (times_to_lose_on_end_query_) {
       --times_to_lose_on_end_query_;
       context->set_times_end_query_succeeds(5);
     }
     return context.Pass();
   }
 
   virtual void setupTree() OVERRIDE {
     parent_->setBounds(gfx::Size(num_children_, 1));
@@ skipping 139 matching lines @@
 
     scoped_refptr<ContentLayer> content_ = ContentLayer::create(&client_);
     content_->setBounds(gfx::Size(10, 10));
     content_->setAnchorPoint(gfx::PointF());
     content_->setIsDrawable(true);
     root_->addChild(content_);
 
     scoped_refptr<TextureLayer> texture_ = TextureLayer::create(NULL);
     texture_->setBounds(gfx::Size(10, 10));
     texture_->setAnchorPoint(gfx::PointF());
-    texture_->setTextureId(FakeWebGraphicsContext3D::kExternalTextureId);
+    texture_->setTextureId(TestWebGraphicsContext3D::kExternalTextureId);
     texture_->setIsDrawable(true);
     root_->addChild(texture_);
 
     scoped_refptr<ContentLayer> mask_ = ContentLayer::create(&client_);
     mask_->setBounds(gfx::Size(10, 10));
     mask_->setAnchorPoint(gfx::PointF());
 
     scoped_refptr<ContentLayer> content_with_mask_ =
         ContentLayer::create(&client_);
     content_with_mask_->setBounds(gfx::Size(10, 10));
@@ skipping 184 matching lines @@
 
   virtual ~LayerTreeHostContextTestFailsImmediately() {}
 
   virtual void beginTest() OVERRIDE {
     postSetNeedsCommitToMainThread();
   }
 
   virtual void afterTest() OVERRIDE {
   }
 
-  virtual scoped_ptr<FakeWebGraphicsContext3D> CreateContext3d() OVERRIDE {
-    scoped_ptr<FakeWebGraphicsContext3D> context =
+  virtual scoped_ptr<TestWebGraphicsContext3D> CreateContext3d() OVERRIDE {
+    scoped_ptr<TestWebGraphicsContext3D> context =
         LayerTreeHostContextTest::CreateContext3d();
     context->loseContextCHROMIUM(GL_GUILTY_CONTEXT_RESET_ARB,
                                  GL_INNOCENT_CONTEXT_RESET_ARB);
     return context.Pass();
   }
 
   virtual void didRecreateOutputSurface(bool succeeded) OVERRIDE {
     EXPECT_FALSE(succeeded);
     // If we make it this far without crashing, we pass!
     endTest();
@@ skipping 90 matching lines @@
 
  private:
   int commits_;
   scoped_refptr<FakeScrollbarLayer> scrollbar_layer_;
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(ScrollbarLayerLostContext)
 
 }  // namespace
 }  // namespace cc