Add ContextProvider overrides to SynchronousCompositorFactory

content/renderer/render_thread_impl.cc

 // Copyright (c) 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 "content/renderer/render_thread_impl.h"
 
 #include <algorithm>
 #include <limits>
 #include <map>
 #include <vector>
@@ skipping 983 matching lines @@
   attributes.antialias = false;
   attributes.noAutomaticFlushes = true;
 
   return make_scoped_ptr(
       WebGraphicsContext3DCommandBufferImpl::CreateOffscreenContext(
           this,
           attributes,
           GURL("chrome://gpu/RenderThreadImpl::CreateOffscreenContext3d")));
 }
 
-scoped_refptr<ContextProviderCommandBuffer>
+scoped_refptr<cc::ContextProvider>
 RenderThreadImpl::OffscreenContextProviderForMainThread() {
   DCHECK(IsMainThread());
 
+#if defined(OS_ANDROID)

[joth, 2013/06/02 19:08:55]

(hmm at some point we may want to move SynchronousCompositorFactory out of
android folder and let all platforms see the null pointer for it, to avoid
proliferation of ifdef...)

+  if (SynchronousCompositorFactory* factory =
+      SynchronousCompositorFactory::GetInstance()) {
+    return factory->OffscreenContextProviderForMainThread();
+  }
+#endif
+
   if (!shared_contexts_main_thread_ ||
       shared_contexts_main_thread_->DestroyedOnMainThread()) {
     shared_contexts_main_thread_ =
         RendererContextProviderCommandBuffer::Create();
     if (shared_contexts_main_thread_ &&
         !shared_contexts_main_thread_->BindToCurrentThread())
       shared_contexts_main_thread_ = NULL;
   }
   return shared_contexts_main_thread_;
 }
 
-scoped_refptr<ContextProviderCommandBuffer>
+scoped_refptr<cc::ContextProvider>
 RenderThreadImpl::OffscreenContextProviderForCompositorThread() {
   DCHECK(IsMainThread());
 
+#if defined(OS_ANDROID)
+  if (SynchronousCompositorFactory* factory =
+      SynchronousCompositorFactory::GetInstance()) {
+    return factory->OffscreenContextProviderForCompositorThread();
+  }
+#endif

[joth, 2013/06/02 19:08:55]

this means shared_contexts_compositor_thread_ (and shared_contexts_main_thread_)
never get assigned. That seems odd? Is it important this keeps a Ref on the
context, and/or returns the same instance on subsequent calls?

we'll never call set_leak_on_destroy() (which we can live with as we'll never be
running Shutdown on android.)
- however could it call set_leak_on_destroy() here (or even pass to c'tor) and
then store the instance as a base-class pointer again?

[boliu, 2013/06/03 18:51:24]

Yes, it needs to be the same one.
This was the reason why I'm holding the ref in the factory rather than here,
because the type is different.

Setting set_leak_on_destroy at contruction time is wrong because it would be
leaking things when the context is lost, which can happen multiple times before
shutdown.

For webview we don't have to worry about it because we never clean have clean
shutdowns.

+
   if (!shared_contexts_compositor_thread_ ||
       shared_contexts_compositor_thread_->DestroyedOnMainThread()) {
     shared_contexts_compositor_thread_ =
         RendererContextProviderCommandBuffer::Create();
   }
   return shared_contexts_compositor_thread_;
 }
 
 AudioRendererMixerManager* RenderThreadImpl::GetAudioRendererMixerManager() {
   if (!audio_renderer_mixer_manager_) {
@@ skipping 296 matching lines @@
 
 void RenderThreadImpl::SetFlingCurveParameters(
     const std::vector<float>& new_touchpad,
     const std::vector<float>& new_touchscreen) {
   webkit_platform_support_->SetFlingCurveParameters(new_touchpad,
                                                     new_touchscreen);
 
 }
 
 }  // namespace content