Make ContextProvider::InitializeOnMainThread implicit.

The creator of a ContextProvider is now responsible for
calling InitializeOnMainThread() and should return NULL if
it fails. Now all places that request a ContextProvider
should check if the provider is NULL instead of initializing
it, and if its not NULL, can assume that it was initialized.

Added some DCHECKs to the context provider implementations
while I'm here.

No change in behaviour, this is covered by existing tests.

TBR=piman,jamesr
BUG=181228

Review URL: https://codereview.chromium.org/12872003

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@188426 0039d316-1c4b-4281-b951-d872f2087c98

5 files changed, 62 insertions, 23 deletions

diff --git a/cc/test/fake_context_provider.cc b/cc/test/fake_context_provider.cc
index ed777fc..e12f783 100644
--- a/cc/test/fake_context_provider.cc
+++ b/cc/test/fake_context_provider.cc
@@ -15,39 +15,51 @@ FakeContextProvider::FakeContextProvider()
 FakeContextProvider::FakeContextProvider(
     const CreateCallback& create_callback)
     : create_callback_(create_callback),
+      bound_(false),
       destroyed_(false) {
 }
 
 FakeContextProvider::~FakeContextProvider() {}
 
 bool FakeContextProvider::InitializeOnMainThread() {
-  if (destroyed_)
-    return false;
-  if (context3d_)
-    return true;
+  DCHECK(!context3d_);
 
   if (create_callback_.is_null())
     context3d_ = TestWebGraphicsContext3D::Create().Pass();
   else
     context3d_ = create_callback_.Run();
-  destroyed_ = !context3d_;
-  return !!context3d_;
+  return context3d_;
 }
 
 bool FakeContextProvider::BindToCurrentThread() {
-  return context3d_->makeContextCurrent();
+  bound_ = true;
+  if (!context3d_->makeContextCurrent()) {
+    base::AutoLock lock(destroyed_lock_);
+    destroyed_ = true;
+    return false;
+  }
+  return true;
 }
 
 WebKit::WebGraphicsContext3D* FakeContextProvider::Context3d() {
+  DCHECK(context3d_);
+  DCHECK(bound_);
+
   return context3d_.get();
 }
 class GrContext* FakeContextProvider::GrContext() {
+  DCHECK(context3d_);
+  DCHECK(bound_);
+
   // TODO(danakj): Make a fake GrContext.
   return NULL;
 }
 
 void FakeContextProvider::VerifyContexts() {
-  if (!Context3d() || Context3d()->isContextLost()) {
+  DCHECK(context3d_);
+  DCHECK(bound_);
+
+  if (context3d_->isContextLost()) {
     base::AutoLock lock(destroyed_lock_);
     destroyed_ = true;
   }
diff --git a/cc/test/fake_context_provider.h b/cc/test/fake_context_provider.h
index c040677..abdd324 100644
--- a/cc/test/fake_context_provider.h
+++ b/cc/test/fake_context_provider.h
@@ -18,10 +18,22 @@ class FakeContextProvider : public cc::ContextProvider {
   typedef base::Callback<scoped_ptr<TestWebGraphicsContext3D>(void)>
     CreateCallback;
 
-  FakeContextProvider();
-  explicit FakeContextProvider(const CreateCallback& create_callback);
+  static scoped_refptr<FakeContextProvider> Create() {
+    scoped_refptr<FakeContextProvider> provider = new FakeContextProvider();
+    if (!provider->InitializeOnMainThread())
+      return NULL;
+    return provider;
+  }
+
+  static scoped_refptr<FakeContextProvider> Create(
+      const CreateCallback& create_callback) {
+    scoped_refptr<FakeContextProvider> provider =
+        new FakeContextProvider(create_callback);
+    if (!provider->InitializeOnMainThread())
+      return NULL;
+    return provider;
+  }
 
-  virtual bool InitializeOnMainThread() OVERRIDE;
   virtual bool BindToCurrentThread() OVERRIDE;
   virtual WebKit::WebGraphicsContext3D* Context3d() OVERRIDE;
   virtual class GrContext* GrContext() OVERRIDE;
@@ -29,10 +41,15 @@ class FakeContextProvider : public cc::ContextProvider {
   virtual bool DestroyedOnMainThread() OVERRIDE;
 
  protected:
+  FakeContextProvider();
+  explicit FakeContextProvider(const CreateCallback& create_callback);
   virtual ~FakeContextProvider();
 
+  bool InitializeOnMainThread();
+
   CreateCallback create_callback_;
   scoped_ptr<WebKit::WebGraphicsContext3D> context3d_;
+  bool bound_;
 
   base::Lock destroyed_lock_;
   bool destroyed_;
diff --git a/cc/test/fake_layer_tree_host_client.cc b/cc/test/fake_layer_tree_host_client.cc
index dbb51b6..a3251bb 100644
--- a/cc/test/fake_layer_tree_host_client.cc
+++ b/cc/test/fake_layer_tree_host_client.cc
@@ -39,14 +39,17 @@ scoped_ptr<InputHandler> FakeLayerImplTreeHostClient::createInputHandler()
 }
 
 scoped_refptr<cc::ContextProvider> FakeLayerImplTreeHostClient::OffscreenContextProviderForMainThread() {
-    if (!m_mainThreadContexts || m_mainThreadContexts->DestroyedOnMainThread())
-        m_mainThreadContexts = new FakeContextProvider;
+    if (!m_mainThreadContexts || m_mainThreadContexts->DestroyedOnMainThread()) {
+        m_mainThreadContexts = FakeContextProvider::Create();
+        if (!m_mainThreadContexts->BindToCurrentThread())
+            m_mainThreadContexts = NULL;
+    }
     return m_mainThreadContexts;
 }
 
 scoped_refptr<cc::ContextProvider> FakeLayerImplTreeHostClient::OffscreenContextProviderForCompositorThread() {
     if (!m_compositorThreadContexts || m_compositorThreadContexts->DestroyedOnMainThread())
-        m_compositorThreadContexts = new FakeContextProvider;
+        m_compositorThreadContexts = FakeContextProvider::Create();
     return m_compositorThreadContexts;
 }
 
diff --git a/cc/test/layer_tree_pixel_test.cc b/cc/test/layer_tree_pixel_test.cc
index 63cfd6f..87cbd8f 100644
--- a/cc/test/layer_tree_pixel_test.cc
+++ b/cc/test/layer_tree_pixel_test.cc
@@ -31,14 +31,20 @@ scoped_ptr<OutputSurface> LayerTreePixelTest::createOutputSurface() {
 
 scoped_refptr<cc::ContextProvider>
 LayerTreePixelTest::OffscreenContextProviderForMainThread() {
-  return new webkit::gpu::ContextProviderInProcess(
-      webkit::gpu::ContextProviderInProcess::IN_PROCESS_COMMAND_BUFFER);
+  scoped_refptr<webkit::gpu::ContextProviderInProcess> provider =
+      webkit::gpu::ContextProviderInProcess::Create(
+          webkit::gpu::ContextProviderInProcess::IN_PROCESS_COMMAND_BUFFER);
+  CHECK(provider->BindToCurrentThread());
+  return provider;
 }
 
 scoped_refptr<cc::ContextProvider>
 LayerTreePixelTest::OffscreenContextProviderForCompositorThread() {
-  return new webkit::gpu::ContextProviderInProcess(
-      webkit::gpu::ContextProviderInProcess::IN_PROCESS_COMMAND_BUFFER);
+  scoped_refptr<webkit::gpu::ContextProviderInProcess> provider =
+      webkit::gpu::ContextProviderInProcess::Create(
+          webkit::gpu::ContextProviderInProcess::IN_PROCESS_COMMAND_BUFFER);
+  CHECK(provider);
+  return provider;
 }
 
 void LayerTreePixelTest::swapBuffersOnThread(LayerTreeHostImpl* host_impl,
diff --git a/cc/test/pixel_test.cc b/cc/test/pixel_test.cc
index 59ea9bb..13e780c 100644
--- a/cc/test/pixel_test.cc
+++ b/cc/test/pixel_test.cc
@@ -54,7 +54,8 @@ PixelTest::PixelTest() : device_viewport_size_(gfx::Size(200, 200)) {}
 PixelTest::~PixelTest() {}
 
 void PixelTest::SetUp() {
-  gfx::InitializeGLBindings(gfx::kGLImplementationOSMesaGL);
+  CHECK(gfx::InitializeGLBindings(gfx::kGLImplementationOSMesaGL));
+
   scoped_ptr<webkit::gpu::WebGraphicsContext3DInProcessCommandBufferImpl>
       context3d(
           new webkit::gpu::WebGraphicsContext3DInProcessCommandBufferImpl);
@@ -68,11 +69,11 @@ void PixelTest::SetUp() {
                                  output_surface_.get(),
                                  resource_provider_.get());
 
-  scoped_refptr<cc::ContextProvider> offscreen_contexts =
-      new webkit::gpu::ContextProviderInProcess(
+  scoped_refptr<webkit::gpu::ContextProviderInProcess> offscreen_contexts =
+      webkit::gpu::ContextProviderInProcess::Create(
           webkit::gpu::ContextProviderInProcess::IN_PROCESS_COMMAND_BUFFER);
-  ASSERT_TRUE(offscreen_contexts->InitializeOnMainThread());
-  resource_provider_->SetOffscreenContextProvider(offscreen_contexts);
+  ASSERT_TRUE(offscreen_contexts->BindToCurrentThread());
+  resource_provider_->set_offscreen_context_provider(offscreen_contexts);
 }
 
 bool PixelTest::PixelsMatchReference(const base::FilePath& ref_file) {