Decouple cc::FakeWebGraphicsContext3D from blink::WGC3D

cc/trees/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/trees/layer_tree_host.h"
 
 #include "base/basictypes.h"
 #include "cc/layers/content_layer.h"
 #include "cc/layers/delegated_frame_provider.h"
 #include "cc/layers/delegated_frame_resource_collection.h"
@@ skipping 23 matching lines @@
 #include "cc/test/render_pass_test_common.h"
 #include "cc/test/test_context_provider.h"
 #include "cc/test/test_web_graphics_context_3d.h"
 #include "cc/trees/layer_tree_host_impl.h"
 #include "cc/trees/layer_tree_impl.h"
 #include "cc/trees/single_thread_proxy.h"
 #include "gpu/GLES2/gl2extchromium.h"
 #include "media/base/media.h"
 
 using media::VideoFrame;
-using blink::WebGraphicsContext3D;
 
 namespace cc {
 namespace {
 
 // These tests deal with losing the 3d graphics context.
 class LayerTreeHostContextTest : public LayerTreeTest {
  public:
   LayerTreeHostContextTest()
       : LayerTreeTest(),
         context3d_(NULL),
@@ skipping 364 matching lines @@
     FakeContentLayerImpl* content_impl = static_cast<FakeContentLayerImpl*>(
         host_impl->active_tree()->root_layer()->children()[0]);
     // Even though the context was lost, we should have a resource. The
     // TestWebGraphicsContext3D ensures that this resource is created with
     // the active context.
     EXPECT_TRUE(content_impl->HaveResourceForTileAt(0, 0));
 
     ContextProvider* contexts = host_impl->offscreen_context_provider();
     if (use_surface_) {
       ASSERT_TRUE(contexts);
-      EXPECT_TRUE(contexts->Context3d());
+      EXPECT_TRUE(contexts->ContextGL());
       // TODO(danakj): Make a fake GrContext.
       // EXPECT_TRUE(contexts->GrContext());
     } else {
       EXPECT_FALSE(contexts);
     }
   }
 
   virtual void AfterTest() OVERRIDE {
     LayerTreeHostContextTestLostContextSucceeds::AfterTest();
     if (use_surface_) {
@@ skipping 519 matching lines @@
         ResourceProvider::Create(child_output_surface_.get(),
                                  NULL,
                                  0,
                                  false,
                                  1);
   }
 
   static void EmptyReleaseCallback(unsigned sync_point, bool lost) {}
 
   virtual void SetupTree() OVERRIDE {
-    blink::WebGraphicsContext3D* context3d =
-        child_output_surface_->context_provider()->Context3d();
+    gpu::gles2::GLES2Interface* gl =
+        child_output_surface_->context_provider()->ContextGL();
 
     scoped_ptr<DelegatedFrameData> frame_data(new DelegatedFrameData);
 
     scoped_ptr<TestRenderPass> pass_for_quad = TestRenderPass::Create();
     pass_for_quad->SetNew(
         // AppendOneOfEveryQuadType() makes a RenderPass quad with this id.
         RenderPass::Id(2, 1),
         gfx::Rect(0, 0, 10, 10),
         gfx::Rect(0, 0, 10, 10),
         gfx::Transform());
@@ skipping 16 matching lines @@
     ResourceProvider::ResourceId resource =
         child_resource_provider_->CreateResource(
             gfx::Size(4, 4),
             GL_CLAMP_TO_EDGE,
             ResourceProvider::TextureUsageAny,
             RGBA_8888);
     ResourceProvider::ScopedWriteLockGL lock(child_resource_provider_.get(),
                                              resource);
 
     gpu::Mailbox mailbox;
-    context3d->genMailboxCHROMIUM(mailbox.name);
-    unsigned sync_point = context3d->insertSyncPoint();
+    gl->GenMailboxCHROMIUM(mailbox.name);
+    GLuint sync_point = gl->InsertSyncPointCHROMIUM();
 
     scoped_refptr<Layer> root = Layer::Create();
     root->SetBounds(gfx::Size(10, 10));
     root->SetAnchorPoint(gfx::PointF());
     root->SetIsDrawable(true);
 
     scoped_refptr<FakeDelegatedRendererLayer> delegated =
         FakeDelegatedRendererLayer::Create(delegated_frame_provider_.get());
     delegated->SetBounds(gfx::Size(10, 10));
     delegated->SetAnchorPoint(gfx::PointF());
@@ skipping 873 matching lines @@
         ui_resource_.reset();
         EndTest();
         break;
       case 4:
         NOTREACHED();
     }
   }
 
   virtual void DidSetVisibleOnImplTree(LayerTreeHostImpl* impl,
                                        bool visible) OVERRIDE {
-    TestWebGraphicsContext3D* context = static_cast<TestWebGraphicsContext3D*>(
-        impl->output_surface()->context_provider()->Context3d());
+    TestWebGraphicsContext3D* context = static_cast<TestContextProvider*>(
+        impl->output_surface()->context_provider().get())->TestContext3d();
     if (!visible) {
       // All resources should have been evicted.
       ASSERT_EQ(0u, context->NumTextures());
       EXPECT_EQ(0u, impl->ResourceIdForUIResource(ui_resource_->id()));
       EXPECT_EQ(2, ui_resource_->resource_create_count);
       EXPECT_EQ(1, ui_resource_->lost_resource_count);
       // Drawing is disabled both because of the evicted resources and
       // because the renderer is not visible.
       EXPECT_FALSE(impl->CanDraw());
       // Make the renderer visible again.
       PostSetVisibleToMainThread(true);
     }
   }
 
   virtual void StepCompleteOnImplThread(LayerTreeHostImpl* impl) OVERRIDE {
-    TestWebGraphicsContext3D* context = static_cast<TestWebGraphicsContext3D*>(
-        impl->output_surface()->context_provider()->Context3d());
+    TestWebGraphicsContext3D* context = static_cast<TestContextProvider*>(
+        impl->output_surface()->context_provider().get())->TestContext3d();
     LayerTreeHostContextTest::CommitCompleteOnThread(impl);
     switch (time_step_) {
       case 1:
         // The resource should have been created on LTHI after the commit.
         ASSERT_EQ(1u, context->NumTextures());
         EXPECT_NE(0u, impl->ResourceIdForUIResource(ui_resource_->id()));
         EXPECT_EQ(1, ui_resource_->resource_create_count);
         EXPECT_EQ(0, ui_resource_->lost_resource_count);
         EXPECT_TRUE(impl->CanDraw());
         // Evict all UI resources. This will trigger a commit.
@@ skipping 91 matching lines @@
  protected:
   FakeContentLayerClient client_;
   scoped_refptr<FakeContentLayer> layer_;
   int num_commits_;
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostContextTestSurfaceCreateCallback);
 
 }  // namespace
 }  // namespace cc