Remove WGC3D::isContextLost references from cc

cc/layers/texture_layer_unittest.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/layers/texture_layer.h"
 
 #include <algorithm>
 #include <string>
 
 #include "base/bind.h"
@@ skipping 33 matching lines @@
 class MockLayerTreeHost : public LayerTreeHost {
  public:
   explicit MockLayerTreeHost(LayerTreeHostClient* client)
       : LayerTreeHost(client, NULL, LayerTreeSettings()) {
     Initialize(NULL);
   }
 
   MOCK_METHOD0(AcquireLayerTextures, void());
   MOCK_METHOD0(SetNeedsCommit, void());
   MOCK_METHOD0(SetNeedsUpdateLayers, void());
-  MOCK_METHOD1(StartRateLimiter, void(WebKit::WebGraphicsContext3D* context));
-  MOCK_METHOD1(StopRateLimiter, void(WebKit::WebGraphicsContext3D* context));
+  MOCK_METHOD1(StartRateLimiter, void(TextureLayerClient* client));
+  MOCK_METHOD1(StopRateLimiter, void(TextureLayerClient* client));
 };
 
 class TextureLayerTest : public testing::Test {
  public:
   TextureLayerTest()
       : fake_client_(
           FakeLayerTreeHostClient(FakeLayerTreeHostClient::DIRECT_3D)),
         host_impl_(&proxy_) {}
 
  protected:
@@ skipping 172 matching lines @@
             layer->VisibleContentOpaqueRegion().ToString());
 
   // Transparent background.
   layer->SetBackgroundColor(SkColorSetARGB(100, 255, 255, 255));
   EXPECT_EQ(Region().ToString(),
             layer->VisibleContentOpaqueRegion().ToString());
 }
 
 class FakeTextureLayerClient : public TextureLayerClient {
  public:
-  FakeTextureLayerClient() : context_(TestWebGraphicsContext3D::Create()) {}
+  FakeTextureLayerClient() {}
 
   virtual unsigned PrepareTexture() OVERRIDE {
     return 0;
   }
 
-  virtual WebKit::WebGraphicsContext3D* Context3d() OVERRIDE {
-    return context_.get();
+  virtual bool IsContextLost() OVERRIDE {
+    return false;
   }
 
+  virtual void RateLimitContext() OVERRIDE {}
+
   virtual bool PrepareTextureMailbox(
       TextureMailbox* mailbox,
       scoped_ptr<SingleReleaseCallback>* release_callback,
       bool use_shared_memory) OVERRIDE {
     *mailbox = TextureMailbox();
     *release_callback = scoped_ptr<SingleReleaseCallback>();
     return true;
   }
 
  private:
-  scoped_ptr<TestWebGraphicsContext3D> context_;
   DISALLOW_COPY_AND_ASSIGN(FakeTextureLayerClient);
 };
 
 TEST_F(TextureLayerTest, RateLimiter) {
   FakeTextureLayerClient client;
   scoped_refptr<TextureLayer> test_layer = TextureLayer::CreateForMailbox(
       &client);
   test_layer->SetIsDrawable(true);
   EXPECT_CALL(*layer_tree_host_, SetNeedsCommit()).Times(AnyNumber());
   layer_tree_host_->SetRootLayer(test_layer);
 
   // Don't rate limit until we invalidate.
   EXPECT_CALL(*layer_tree_host_, StartRateLimiter(_)).Times(0);
   test_layer->SetRateLimitContext(true);
   Mock::VerifyAndClearExpectations(layer_tree_host_.get());
 
   // Do rate limit after we invalidate.
-  EXPECT_CALL(*layer_tree_host_, StartRateLimiter(client.Context3d()));
+  EXPECT_CALL(*layer_tree_host_, StartRateLimiter(&client));
   test_layer->SetNeedsDisplay();
   Mock::VerifyAndClearExpectations(layer_tree_host_.get());
 
   // Stop rate limiter when we don't want it any more.
-  EXPECT_CALL(*layer_tree_host_, StopRateLimiter(client.Context3d()));
+  EXPECT_CALL(*layer_tree_host_, StopRateLimiter(&client));
   test_layer->SetRateLimitContext(false);
   Mock::VerifyAndClearExpectations(layer_tree_host_.get());
 
   // Or we clear the client.
   test_layer->SetRateLimitContext(true);
-  EXPECT_CALL(*layer_tree_host_, StopRateLimiter(client.Context3d()));
+  EXPECT_CALL(*layer_tree_host_, StopRateLimiter(&client));
   EXPECT_CALL(*layer_tree_host_, SetNeedsCommit()).Times(AnyNumber());
   test_layer->ClearClient();
   Mock::VerifyAndClearExpectations(layer_tree_host_.get());
 
   // Reset to a layer with a client, that started the rate limiter.
   test_layer = TextureLayer::CreateForMailbox(
       &client);
   test_layer->SetIsDrawable(true);
   test_layer->SetRateLimitContext(true);
   EXPECT_CALL(*layer_tree_host_, SetNeedsCommit()).Times(AnyNumber());
   layer_tree_host_->SetRootLayer(test_layer);
   EXPECT_CALL(*layer_tree_host_, StartRateLimiter(_)).Times(0);
   Mock::VerifyAndClearExpectations(layer_tree_host_.get());
-  EXPECT_CALL(*layer_tree_host_, StartRateLimiter(client.Context3d()));
+  EXPECT_CALL(*layer_tree_host_, StartRateLimiter(&client));
   test_layer->SetNeedsDisplay();
   Mock::VerifyAndClearExpectations(layer_tree_host_.get());
 
   // Stop rate limiter when we're removed from the tree.
-  EXPECT_CALL(*layer_tree_host_, StopRateLimiter(client.Context3d()));
+  EXPECT_CALL(*layer_tree_host_, StopRateLimiter(&client));
   layer_tree_host_->SetRootLayer(NULL);
   Mock::VerifyAndClearExpectations(layer_tree_host_.get());
 }
 
 class MockMailboxCallback {
  public:
   MOCK_METHOD3(Release, void(const std::string& mailbox,
                              unsigned sync_point,
                              bool lost_resource));
   MOCK_METHOD3(Release2, void(base::SharedMemory* shared_memory,
@@ skipping 559 matching lines @@
 SINGLE_AND_MULTI_THREAD_DIRECT_RENDERER_TEST_F(
     TextureLayerImplWithMailboxThreadedCallback);
 
 
 class TextureLayerNoMailboxIsActivatedDuringCommit : public LayerTreeTest,
                                                      public TextureLayerClient {
  protected:
   TextureLayerNoMailboxIsActivatedDuringCommit()
       : wait_thread_("WAIT"),
         wait_event_(false, false),
-        context_(TestWebGraphicsContext3D::Create()) {
+        texture_(0u) {
     wait_thread_.Start();
   }
 
   virtual void BeginTest() OVERRIDE {
     activate_count_ = 0;
 
     gfx::Size bounds(100, 100);
     root_ = Layer::Create();
     root_->SetAnchorPoint(gfx::PointF());
     root_->SetBounds(bounds);
 
     layer_ = TextureLayer::Create(this);
     layer_->SetIsDrawable(true);
     layer_->SetAnchorPoint(gfx::PointF());
     layer_->SetBounds(bounds);
 
     root_->AddChild(layer_);
     layer_tree_host()->SetRootLayer(root_);
     layer_tree_host()->SetViewportSize(bounds);
 
     PostSetNeedsCommitToMainThread();
   }
 
+  virtual scoped_ptr<OutputSurface> CreateOutputSurface(bool fallback)
+      OVERRIDE {
+    scoped_refptr<TestContextProvider> provider = TestContextProvider::Create();
+    texture_ = provider->UnboundTestContext3d()->createExternalTexture();
+    return FakeOutputSurface::Create3d(provider).PassAs<OutputSurface>();
+  }
+
   // TextureLayerClient implementation.
   virtual unsigned PrepareTexture() OVERRIDE {
-    context_->makeContextCurrent();
-    return context_->createTexture();
+    return texture_;
   }
-  virtual WebKit::WebGraphicsContext3D* Context3d() OVERRIDE {
-    return context_.get();
-  }
+  virtual bool IsContextLost() OVERRIDE { return false; }
+  virtual void RateLimitContext() OVERRIDE {}
   virtual bool PrepareTextureMailbox(
       TextureMailbox* mailbox,
       scoped_ptr<SingleReleaseCallback>* release_callback,
       bool use_shared_memory) OVERRIDE {
     return false;
   }
 
   virtual void WillActivateTreeOnThread(LayerTreeHostImpl* impl) OVERRIDE {
     // Slow down activation so the main thread DidCommit() will run if
     // not blocked.
@@ skipping 57 matching lines @@
       }
     }
   }
 
 
   virtual void AfterTest() OVERRIDE {}
 
   base::Thread wait_thread_;
   base::WaitableEvent wait_event_;
   base::Lock activate_lock_;
+  unsigned texture_;
   int activate_count_;
-  int activate_commit_;
   scoped_refptr<Layer> root_;
   scoped_refptr<TextureLayer> layer_;
-  scoped_ptr<TestWebGraphicsContext3D> context_;
 };
 
 SINGLE_AND_MULTI_THREAD_DIRECT_RENDERER_TEST_F(
     TextureLayerNoMailboxIsActivatedDuringCommit);
 
 class TextureLayerMailboxIsActivatedDuringCommit : public LayerTreeTest {
  protected:
   TextureLayerMailboxIsActivatedDuringCommit()
       : wait_thread_("WAIT"),
         wait_event_(false, false) {
@@ skipping 379 matching lines @@
   provider->ReceiveReturnsFromParent(returned);
 }
 
 // Check that ClearClient correctly clears the state so that the impl side
 // doesn't try to use a texture that could have been destroyed.
 class TextureLayerClientTest
     : public LayerTreeTest,
       public TextureLayerClient {
  public:
   TextureLayerClientTest()
-      : context_(NULL),
-        texture_(0),
+      : texture_(0),
         commit_count_(0),
         expected_used_textures_on_draw_(0),
         expected_used_textures_on_commit_(0) {}
 
   virtual scoped_ptr<OutputSurface> CreateOutputSurface(bool fallback)
       OVERRIDE {
-    scoped_ptr<TestWebGraphicsContext3D> context(
-        TestWebGraphicsContext3D::Create());
-    context_ = context.get();
-    texture_ = context->createTexture();
-    return FakeOutputSurface::Create3d(context.Pass()).PassAs<OutputSurface>();
+    scoped_refptr<TestContextProvider> provider = TestContextProvider::Create();
+    texture_ = provider->UnboundTestContext3d()->createExternalTexture();
+    return FakeOutputSurface::Create3d(provider).PassAs<OutputSurface>();
   }
 
-  virtual unsigned PrepareTexture() OVERRIDE {
-    return texture_;
-  }
-
-  virtual WebKit::WebGraphicsContext3D* Context3d() OVERRIDE {
-    return context_;
-  }
+  virtual unsigned PrepareTexture() OVERRIDE { return texture_; }
+  virtual bool IsContextLost() OVERRIDE { return false; }
+  virtual void RateLimitContext() OVERRIDE { }
 
   virtual bool PrepareTextureMailbox(
       TextureMailbox* mailbox,
       scoped_ptr<SingleReleaseCallback>* release_callback,
       bool use_shared_memory) OVERRIDE {
     return false;
   }
 
   virtual void SetupTree() OVERRIDE {
     scoped_refptr<Layer> root = Layer::Create();
@@ skipping 22 matching lines @@
   virtual void DidCommitAndDrawFrame() OVERRIDE {
     ++commit_count_;
     switch (commit_count_) {
       case 1:
         texture_layer_->ClearClient();
         texture_layer_->SetNeedsDisplay();
         {
           base::AutoLock lock(lock_);
           expected_used_textures_on_commit_ = 0;
         }
-        texture_ = 0;
         break;
       case 2:
         EndTest();
         break;
       default:
         NOTREACHED();
         break;
     }
   }
 
   virtual void BeginCommitOnThread(LayerTreeHostImpl* host_impl) OVERRIDE {
     base::AutoLock lock(lock_);
     expected_used_textures_on_draw_ = expected_used_textures_on_commit_;
   }
 
   virtual bool PrepareToDrawOnThread(LayerTreeHostImpl* host_impl,
                                      LayerTreeHostImpl::FrameData* frame_data,
                                      bool result) OVERRIDE {
-    context_->ResetUsedTextures();
+    ContextForImplThread(host_impl)->ResetUsedTextures();
     return true;
   }
 
   virtual void SwapBuffersOnThread(LayerTreeHostImpl* host_impl,
                                    bool result) OVERRIDE {
     ASSERT_TRUE(result);
-    EXPECT_EQ(expected_used_textures_on_draw_, context_->NumUsedTextures());
+    EXPECT_EQ(expected_used_textures_on_draw_,
+              ContextForImplThread(host_impl)->NumUsedTextures());
   }
 
   virtual void AfterTest() OVERRIDE {}
 
  private:
+  TestWebGraphicsContext3D* ContextForImplThread(LayerTreeHostImpl* host_impl) {
+    return static_cast<TestWebGraphicsContext3D*>(
+        host_impl->output_surface()->context_provider()->Context3d());
+  }
+
   scoped_refptr<TextureLayer> texture_layer_;
-  TestWebGraphicsContext3D* context_;
   unsigned texture_;
   int commit_count_;
 
   // Used only on thread.
   unsigned expected_used_textures_on_draw_;
 
   // Used on either thread, protected by lock_.
   base::Lock lock_;
   unsigned expected_used_textures_on_commit_;
 };
 
 // The TextureLayerClient does not use mailboxes, so can't use a delegating
 // renderer.
 SINGLE_AND_MULTI_THREAD_DIRECT_RENDERER_TEST_F(TextureLayerClientTest);
 
 
 // Checks that changing a texture in the client for a TextureLayer that's
 // invisible correctly works without drawing a deleted texture. See
 // crbug.com/266628
 class TextureLayerChangeInvisibleTest
     : public LayerTreeTest,
       public TextureLayerClient {
  public:
   TextureLayerChangeInvisibleTest()
-      : client_context_(TestWebGraphicsContext3D::Create()),
-        texture_(client_context_->createTexture()),
-        texture_to_delete_on_next_commit_(0),
+      : texture_(0u),
         prepare_called_(0),
         commit_count_(0),
         expected_texture_on_draw_(0) {}
 
+  virtual scoped_ptr<OutputSurface> CreateOutputSurface(bool fallback)
+      OVERRIDE {
+    scoped_refptr<TestContextProvider> provider = TestContextProvider::Create();
+    texture_ = provider->UnboundTestContext3d()->createExternalTexture();
+    return FakeOutputSurface::Create3d(provider).PassAs<OutputSurface>();
+  }
+
   // TextureLayerClient implementation.
   virtual unsigned PrepareTexture() OVERRIDE {
     ++prepare_called_;
     return texture_;
   }
-
-  // TextureLayerClient implementation.
-  virtual WebKit::WebGraphicsContext3D* Context3d() OVERRIDE {
-    return client_context_.get();
-  }
-
-  // TextureLayerClient implementation.
+  virtual bool IsContextLost() OVERRIDE { return false; }
+  virtual void RateLimitContext() OVERRIDE {}
   virtual bool PrepareTextureMailbox(
       cc::TextureMailbox* mailbox,
       scoped_ptr<SingleReleaseCallback>* release_callback,
       bool use_shared_memory) OVERRIDE {
     return false;
   }
 
   virtual void SetupTree() OVERRIDE {
     scoped_refptr<Layer> root = Layer::Create();
     root->SetBounds(gfx::Size(10, 10));
@@ skipping 30 matching lines @@
     switch (commit_count_) {
       case 1:
         // We should have updated the layer, committing the texture.
         EXPECT_EQ(1, prepare_called_);
         // Make layer invisible.
         parent_layer_->SetOpacity(0.f);
         break;
       case 2: {
         // Layer shouldn't have been updated.
         EXPECT_EQ(1, prepare_called_);
-        // Change the texture.
-        texture_to_delete_on_next_commit_ = texture_;
-        texture_ = client_context_->createTexture();
         texture_layer_->SetNeedsDisplay();
         // Force a change to make sure we draw a frame.
         solid_layer_->SetBackgroundColor(SK_ColorGRAY);
         break;
       }
       case 3:
         EXPECT_EQ(1, prepare_called_);
-        client_context_->deleteTexture(texture_to_delete_on_next_commit_);
-        texture_to_delete_on_next_commit_ = 0;
         // Make layer visible again.
         parent_layer_->SetOpacity(1.f);
         break;
       case 4: {
         // Layer should have been updated.
         EXPECT_EQ(2, prepare_called_);
         texture_layer_->ClearClient();
-        client_context_->deleteTexture(texture_);
         texture_ = 0;
         break;
       }
       case 5:
         EndTest();
         break;
       default:
         NOTREACHED();
         break;
     }
@@ skipping 39 matching lines @@
 
  private:
   TestWebGraphicsContext3D* ContextForImplThread(LayerTreeHostImpl* host_impl) {
     return static_cast<TestWebGraphicsContext3D*>(
         host_impl->output_surface()->context_provider()->Context3d());
   }
 
   scoped_refptr<SolidColorLayer> solid_layer_;
   scoped_refptr<Layer> parent_layer_;
   scoped_refptr<TextureLayer> texture_layer_;
-  scoped_ptr<TestWebGraphicsContext3D> client_context_;
 
   // Used on the main thread, and on the impl thread while the main thread is
   // blocked.
   unsigned texture_;
 
   // Used on the main thread.
-  unsigned texture_to_delete_on_next_commit_;
   int prepare_called_;
   int commit_count_;
 
   // Used on the compositor thread.
   unsigned expected_texture_on_draw_;
 };
 
 // The TextureLayerChangeInvisibleTest does not use mailboxes, so can't use a
 // delegating renderer.
 SINGLE_AND_MULTI_THREAD_DIRECT_RENDERER_TEST_F(TextureLayerChangeInvisibleTest);
 
 // Checks that TextureLayer::Update does not cause an extra commit when setting
 // the texture mailbox.
 class TextureLayerNoExtraCommitForMailboxTest
     : public LayerTreeTest,
       public TextureLayerClient {
  public:
   TextureLayerNoExtraCommitForMailboxTest()
       : prepare_mailbox_count_(0) {}
 
   // TextureLayerClient implementation.
   virtual unsigned PrepareTexture() OVERRIDE {
     NOTREACHED();
     return 0;
   }
-
-  // TextureLayerClient implementation.
-  virtual WebKit::WebGraphicsContext3D* Context3d() OVERRIDE {
-    NOTREACHED();
-    return NULL;
-  }
+  virtual bool IsContextLost() OVERRIDE { return false; }
+  virtual void RateLimitContext() OVERRIDE {}
 
   virtual bool PrepareTextureMailbox(
       cc::TextureMailbox* mailbox,
       scoped_ptr<SingleReleaseCallback>* release_callback,
       bool use_shared_memory) OVERRIDE {
     prepare_mailbox_count_++;
     // Alternate between two mailboxes to ensure that the TextureLayer updates
     // and commits.
     if (prepare_mailbox_count_ % 2 == 0)
       *mailbox = MakeMailbox('1');
@@ skipping 83 matching lines @@
         prepare_called_(0),
         commit_count_(0) {
     mailbox_ = MakeMailbox('1');
   }
 
   // TextureLayerClient implementation.
   virtual unsigned PrepareTexture() OVERRIDE {
     NOTREACHED();
     return 0;
   }
+  virtual bool IsContextLost() OVERRIDE { return false; }
+  virtual void RateLimitContext() OVERRIDE {}
 
-  // TextureLayerClient implementation.
-  virtual WebKit::WebGraphicsContext3D* Context3d() OVERRIDE {
-    NOTREACHED();
-    return NULL;
-  }
-
-  // TextureLayerClient implementation.
   virtual bool PrepareTextureMailbox(
       cc::TextureMailbox* mailbox,
       scoped_ptr<SingleReleaseCallback>* release_callback,
       bool use_shared_memory) OVERRIDE {
     ++prepare_called_;
     if (!mailbox_changed_)
       return false;
     *mailbox = mailbox_;
     *release_callback = SingleReleaseCallback::Create(
         base::Bind(&TextureLayerChangeInvisibleMailboxTest::MailboxReleased,
@@ skipping 119 matching lines @@
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(TextureLayerChangeInvisibleMailboxTest);
 
 // Test recovering from a lost context.
 class TextureLayerLostContextTest
     : public LayerTreeTest,
       public TextureLayerClient {
  public:
   TextureLayerLostContextTest()
-      : texture_(0),
+      : context_lost_(false),
         draw_count_(0) {}
 
   virtual scoped_ptr<OutputSurface> CreateOutputSurface(bool fallback)
       OVERRIDE {
-    texture_context_ = TestWebGraphicsContext3D::Create();
-    texture_ = texture_context_->createTexture();
     return CreateFakeOutputSurface();
   }
 
   virtual unsigned PrepareTexture() OVERRIDE {
     if (draw_count_ == 0) {
-      texture_context_->loseContextCHROMIUM(GL_GUILTY_CONTEXT_RESET_ARB,
-          GL_INNOCENT_CONTEXT_RESET_ARB);
+      context_lost_ = true;
+      return 0u;
     }
-    return texture_;
+    return 1u;
   }
 
-  virtual WebKit::WebGraphicsContext3D* Context3d() OVERRIDE {
-    return texture_context_.get();
+  virtual bool IsContextLost() OVERRIDE {
+    return context_lost_;
   }
+  virtual void RateLimitContext() OVERRIDE {}
 
   virtual bool PrepareTextureMailbox(
       TextureMailbox* mailbox,
       scoped_ptr<SingleReleaseCallback>* release_callback,
       bool use_shared_memory) OVERRIDE {
     return false;
   }
 
   virtual void SetupTree() OVERRIDE {
     scoped_refptr<Layer> root = Layer::Create();
@@ skipping 15 matching lines @@
 
   virtual bool PrepareToDrawOnThread(LayerTreeHostImpl* host_impl,
                                      LayerTreeHostImpl::FrameData* frame_data,
                                      bool result) OVERRIDE {
     LayerImpl* root = host_impl->RootLayer();
     TextureLayerImpl* texture_layer =
         static_cast<TextureLayerImpl*>(root->children()[0]);
     if (++draw_count_ == 1)
       EXPECT_EQ(0u, texture_layer->texture_id());
     else
-      EXPECT_EQ(texture_, texture_layer->texture_id());
+      EXPECT_EQ(1u, texture_layer->texture_id());
     return true;
   }
 
   virtual void DidCommitAndDrawFrame() OVERRIDE {
     EndTest();
   }
 
   virtual void AfterTest() OVERRIDE {}
 
  private:
   scoped_refptr<TextureLayer> texture_layer_;
-  scoped_ptr<TestWebGraphicsContext3D> texture_context_;
-  unsigned texture_;
+  bool context_lost_;
   int draw_count_;
 };
 
 SINGLE_AND_MULTI_THREAD_DIRECT_RENDERER_TEST_F(TextureLayerLostContextTest);
 
 class TextureLayerWithMailboxMainThreadDeleted : public LayerTreeTest {
  public:
   void ReleaseCallback(unsigned sync_point, bool lost_resource) {
     EXPECT_EQ(true, main_thread_.CalledOnValidThread());
     EXPECT_FALSE(lost_resource);
@@ skipping 134 matching lines @@
   int callback_count_;
   scoped_refptr<Layer> root_;
   scoped_refptr<TextureLayer> layer_;
 };
 
 SINGLE_AND_MULTI_THREAD_DIRECT_RENDERER_TEST_F(
     TextureLayerWithMailboxImplThreadDeleted);
 
 }  // namespace
 }  // namespace cc