Remove offscreen compositor contexts.

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 546 matching lines @@
   if (webkit_platform_support_)
     blink::shutdown();
 
   lazy_tls.Pointer()->Set(NULL);
 
   // TODO(port)
 #if defined(OS_WIN)
   // Clean up plugin channels before this thread goes away.
   NPChannelBase::CleanupChannels();
 #endif
-
-  // Leak shared contexts on other threads, as we can not get to the correct
-  // thread to destroy them.
-  if (offscreen_compositor_contexts_.get())
-    offscreen_compositor_contexts_->set_leak_on_destroy();

[piman, 2014/04/24 00:14:00]

nit: Is there anything calling set_leak_on_destroy() any more? Can we remove it?

[danakj, 2014/04/24 15:01:32]

Done.

 }
 
 bool RenderThreadImpl::Send(IPC::Message* msg) {
   // Certain synchronous messages cannot always be processed synchronously by
   // the browser, e.g., putting up UI and waiting for the user. This could cause
   // a complete hang of Chrome if a windowed plug-in is trying to communicate
   // with the renderer thread since the browser's UI thread could be stuck
   // (within a Windows API call) trying to synchronously communicate with the
   // plug-in.  The remedy is to pump messages on this thread while the browser
   // is processing this request. This creates an opportunity for re-entrancy
@@ skipping 433 matching lines @@
   return make_scoped_ptr(
       WebGraphicsContext3DCommandBufferImpl::CreateOffscreenContext(
           gpu_channel_host.get(),
           attributes,
           lose_context_when_out_of_memory,
           GURL("chrome://gpu/RenderThreadImpl::CreateOffscreenContext3d"),
           WebGraphicsContext3DCommandBufferImpl::SharedMemoryLimits(),
           NULL));
 }
 
-scoped_refptr<cc::ContextProvider>
-RenderThreadImpl::OffscreenCompositorContextProvider() {
-  DCHECK(IsMainThread());
-
-#if defined(OS_ANDROID)
-  if (SynchronousCompositorFactory* factory =
-      SynchronousCompositorFactory::GetInstance()) {
-    if (compositor_message_loop_proxy_)
-      return factory->GetOffscreenContextProviderForCompositorThread();
-    return factory->GetSharedOffscreenContextProviderForMainThread();
-  }
-#endif
-
-  if (!offscreen_compositor_contexts_.get() ||
-      offscreen_compositor_contexts_->DestroyedOnMainThread()) {
-    offscreen_compositor_contexts_ = ContextProviderCommandBuffer::Create(
-        CreateOffscreenContext3d(),
-        "Compositor-Offscreen");
-  }
-  return offscreen_compositor_contexts_;
-}
-
 scoped_refptr<webkit::gpu::ContextProviderWebContext>
 RenderThreadImpl::SharedMainThreadContextProvider() {
   DCHECK(IsMainThread());
 #if defined(OS_ANDROID)
   if (SynchronousCompositorFactory* factory =
       SynchronousCompositorFactory::GetInstance())
     return factory->GetSharedOffscreenContextProviderForMainThread();
 #endif
 
   if (!shared_main_thread_contexts_ ||
       shared_main_thread_contexts_->DestroyedOnMainThread()) {
-    if (compositor_message_loop_proxy_) {
-      // In threaded compositing mode, we have to create a new ContextProvider
-      // to bind to the main thread since the compositor's is bound to the
-      // compositor thread.
-      shared_main_thread_contexts_ =
-          ContextProviderCommandBuffer::Create(CreateOffscreenContext3d(),
-                                               "Offscreen-MainThread");
-    } else {
-      // In single threaded mode, we can use the same context provider.
-      shared_main_thread_contexts_ =
-          static_cast<ContextProviderCommandBuffer*>(
-                OffscreenCompositorContextProvider().get());
-    }
+    shared_main_thread_contexts_ = ContextProviderCommandBuffer::Create(
+        CreateOffscreenContext3d(), "Offscreen-MainThread");
   }
   if (shared_main_thread_contexts_ &&
       !shared_main_thread_contexts_->BindToCurrentThread())
     shared_main_thread_contexts_ = NULL;
   return shared_main_thread_contexts_;
 }
 
 AudioRendererMixerManager* RenderThreadImpl::GetAudioRendererMixerManager() {
   if (!audio_renderer_mixer_manager_) {
     audio_renderer_mixer_manager_.reset(new AudioRendererMixerManager(
@@ skipping 438 matching lines @@
   hidden_widget_count_--;
 
   if (!GetContentClient()->renderer()->RunIdleHandlerWhenWidgetsHidden()) {
     return;
   }
 
   ScheduleIdleHandler(kLongIdleHandlerDelayMs);
 }
 
 }  // namespace content