Remove renderer dependencies from the GPU client classes.

content/renderer/gpu/webgraphicscontext3d_command_buffer_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.
 
-#if defined(ENABLE_GPU)
-
 #include "content/renderer/gpu/webgraphicscontext3d_command_buffer_impl.h"
 
 #include "third_party/khronos/GLES2/gl2.h"
 #ifndef GL_GLEXT_PROTOTYPES
 #define GL_GLEXT_PROTOTYPES 1
 #endif
 #include "third_party/khronos/GLES2/gl2ext.h"
 
 #include <algorithm>
 #include <set>
 
 #include "base/bind.h"
 #include "base/lazy_instance.h"
 #include "base/string_tokenizer.h"
 #include "base/command_line.h"
 #include "base/debug/trace_event.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "base/metrics/histogram.h"
 #include "base/synchronization/lock.h"
-#include "content/common/child_process.h"
 #include "content/public/common/content_switches.h"
 #include "content/renderer/gpu/command_buffer_proxy.h"
 #include "content/renderer/gpu/gpu_channel_host.h"
-#include "content/renderer/render_thread_impl.h"
 #include "content/renderer/render_view_impl.h"
 #include "gpu/command_buffer/client/gles2_implementation.h"
 #include "gpu/command_buffer/common/constants.h"
-#include "third_party/WebKit/Source/WebKit/chromium/public/WebDocument.h"
-#include "third_party/WebKit/Source/WebKit/chromium/public/WebFrame.h"
-#include "third_party/WebKit/Source/WebKit/chromium/public/WebView.h"
 #include "webkit/glue/gl_bindings_skia_cmd_buffer.h"
 
 static base::LazyInstance<base::Lock>::Leaky
     g_all_shared_contexts_lock = LAZY_INSTANCE_INITIALIZER;
 static base::LazyInstance<std::set<WebGraphicsContext3DCommandBufferImpl*> >
     g_all_shared_contexts = LAZY_INSTANCE_INITIALIZER;
 
 namespace {
 
 void ClearSharedContexts() {
   base::AutoLock lock(g_all_shared_contexts_lock.Get());
   g_all_shared_contexts.Pointer()->clear();
 }
 
 } // namespace anonymous
 
 
-WebGraphicsContext3DCommandBufferImpl::WebGraphicsContext3DCommandBufferImpl()
+WebGraphicsContext3DCommandBufferImpl::WebGraphicsContext3DCommandBufferImpl(
+    int surface_id,
+    const GURL& active_url,
+    const base::WeakPtr<WebGraphicsContext3DSwapBuffersClient>& swap_client)
     : initialize_failed_(false),
       context_(NULL),
       gl_(NULL),
-      web_view_(NULL),
-#if defined(OS_MACOSX)
-      plugin_handle_(NULL),
-#endif  // defined(OS_MACOSX)
+      host_(NULL),
+      surface_id_(surface_id),
+      active_url_(active_url),
+      swap_client_(swap_client),
       context_lost_callback_(0),
       context_lost_reason_(GL_NO_ERROR),
       swapbuffers_complete_callback_(0),
       gpu_preference_(gfx::PreferIntegratedGpu),
       cached_width_(0),
       cached_height_(0),
       bound_fbo_(0),
       weak_ptr_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)) {
 }
 
 WebGraphicsContext3DCommandBufferImpl::
     ~WebGraphicsContext3DCommandBufferImpl() {
   if (host_) {
     if (host_->WillGpuSwitchOccur(false, gpu_preference_)) {
       host_->ForciblyCloseChannel();
       ClearSharedContexts();
     }
   }
 
   {
     base::AutoLock lock(g_all_shared_contexts_lock.Get());
     g_all_shared_contexts.Pointer()->erase(this);
   }
   delete context_;
 }
 
-bool WebGraphicsContext3DCommandBufferImpl::initialize(
-    WebGraphicsContext3D::Attributes attributes,
-    WebKit::WebView* web_view,
-    bool render_directly_to_web_view) {
+bool WebGraphicsContext3DCommandBufferImpl::Initialize(
+    const WebGraphicsContext3D::Attributes& attributes) {
   DCHECK(!context_);
   TRACE_EVENT0("gpu", "WebGfxCtx3DCmdBfrImpl::initialize");
-  RenderThreadImpl* render_thread = RenderThreadImpl::current();
-  if (!render_thread)
+  GpuChannelHostFactory* factory = GpuChannelHostFactory::instance();
+  if (!factory)
     return false;
 
   // The noExtensions and canRecoverFromContextLoss flags are
   // currently used as hints that we are creating a context on
   // behalf of WebGL or accelerated 2D canvas, respectively.
   if (attributes.noExtensions || !attributes.canRecoverFromContextLoss)
     gpu_preference_ = gfx::PreferDiscreteGpu;
 
   bool retry = false;
 
   // Note similar code in Pepper PlatformContext3DImpl::Init.
   do {
-    host_ = render_thread->EstablishGpuChannelSync(
+    host_ = factory->EstablishGpuChannelSync(
         content::
         CAUSE_FOR_GPU_LAUNCH_WEBGRAPHICSCONTEXT3DCOMMANDBUFFERIMPL_INITIALIZE);
     if (!host_)
       return false;
     DCHECK(host_->state() == GpuChannelHost::kConnected);
 
     if (!retry) {
       // If the creation of this context requires all contexts for this
       // renderer to be destroyed on the GPU process side, then drop the
       // channel and recreate it.
@@ skipping 10 matching lines @@
   const content::GPUInfo& gpu_info = host_->gpu_info();
   UMA_HISTOGRAM_ENUMERATION(
       "GPU.WebGraphicsContext3D_Init_CanLoseContext",
       attributes.canRecoverFromContextLoss * 2 + gpu_info.can_lose_context,
       4);
   if (attributes.canRecoverFromContextLoss == false) {
     if (gpu_info.can_lose_context)
       return false;
   }
 
-  if (web_view && web_view->mainFrame())
-    active_url_ = GURL(web_view->mainFrame()->document().url());
-
   attributes_ = attributes;
-  render_directly_to_web_view_ = render_directly_to_web_view;
-  if (render_directly_to_web_view_) {
-    RenderViewImpl* render_view = RenderViewImpl::FromWebView(web_view);
-    if (!render_view)
-      return false;
-    surface_id_ = render_view->surface_id();
-    web_view_ = web_view;
-  }
   return true;
 }
 
 bool WebGraphicsContext3DCommandBufferImpl::MaybeInitializeGL() {
   if (context_)
     return true;
   if (initialize_failed_)
     return false;
 
   TRACE_EVENT0("gpu", "WebGfxCtx3DCmdBfrImpl::MaybeInitializeGL");
 
   // If the context is being initialized on something other than the main
-  // thread, then drop the web_view_ pointer so we don't accidentally
-  // dereference it.
-  MessageLoop* main_message_loop =
-      ChildProcess::current()->main_thread()->message_loop();
-  if (MessageLoop::current() != main_message_loop)
-    web_view_ = NULL;
+  // thread, then make sure the swap_client_ pointer is NULL so we don't
+  // accidentally dereference it.
+  GpuChannelHostFactory* factory = GpuChannelHostFactory::instance();
+  if (!factory || !factory->IsMainThread())
+    DCHECK(!swap_client_.get());
 
   // Convert WebGL context creation attributes into RendererGLContext / EGL size
   // requests.
   const int alpha_size = attributes_.alpha ? 8 : 0;
   const int depth_size = attributes_.depth ? 24 : 0;
   const int stencil_size = attributes_.stencil ? 8 : 0;
   const int samples = attributes_.antialias ? 4 : 0;
   const int sample_buffers = attributes_.antialias ? 1 : 0;
   const int32 attribs[] = {
     RendererGLContext::ALPHA_SIZE, alpha_size,
@@ skipping 12 matching lines @@
   // to ensure that the context we picked for our share group isn't deleted.
   // (There's also a lock in our destructor.)
   {
     base::AutoLock lock(g_all_shared_contexts_lock.Get());
     RendererGLContext* share_group = NULL;
     if (attributes_.shareResources) {
       share_group = g_all_shared_contexts.Pointer()->empty() ?
           NULL : (*g_all_shared_contexts.Pointer()->begin())->context_;
     }
 
-    if (render_directly_to_web_view_) {
+    if (surface_id_) {
       context_ = RendererGLContext::CreateViewContext(
           host_,
           surface_id_,
           share_group,
           preferred_extensions,
           attribs,
           active_url_,
           gpu_preference_);
     } else {
       context_ = RendererGLContext::CreateOffscreenContext(
@@ skipping 77 matching lines @@
       parent_context_impl ? parent_context_impl->context() : NULL);
 }
 
 WebGLId WebGraphicsContext3DCommandBufferImpl::getPlatformTextureId() {
   return context_->GetParentTextureId();
 }
 
 void WebGraphicsContext3DCommandBufferImpl::prepareTexture() {
   // Copies the contents of the off-screen render target into the texture
   // used by the compositor.
-  RenderViewImpl* renderview =
-      web_view_ ? RenderViewImpl::FromWebView(web_view_) : NULL;
-  if (renderview)
-    renderview->OnViewContextSwapBuffersPosted();
+  if (swap_client_.get())
+    swap_client_->OnViewContextSwapBuffersPosted();
   context_->SwapBuffers();
   context_->Echo(base::Bind(
       &WebGraphicsContext3DCommandBufferImpl::OnSwapBuffersComplete,
       weak_ptr_factory_.GetWeakPtr()));
 #if defined(OS_MACOSX)
   // It appears that making the compositor's on-screen context current on
   // other platforms implies this flush. TODO(kbr): this means that the
   // TOUCH build and, in the future, other platforms might need this.
   gl_->Flush();
 #endif
 }
 
 void WebGraphicsContext3DCommandBufferImpl::postSubBufferCHROMIUM(
     int x, int y, int width, int height) {
   // Same flow control as WebGraphicsContext3DCommandBufferImpl::prepareTexture
   // (see above).
-  RenderViewImpl* renderview =
-      web_view_ ? RenderViewImpl::FromWebView(web_view_) : NULL;
-  if (renderview)
-    renderview->OnViewContextSwapBuffersPosted();
+  if (swap_client_.get())
+    swap_client_->OnViewContextSwapBuffersPosted();
   gl_->PostSubBufferCHROMIUM(x, y, width, height);
   context_->Echo(base::Bind(
       &WebGraphicsContext3DCommandBufferImpl::OnSwapBuffersComplete,
       weak_ptr_factory_.GetWeakPtr()));
 }
 
 void WebGraphicsContext3DCommandBufferImpl::reshape(int width, int height) {
   cached_width_ = width;
   cached_height_ = height;
 
@@ skipping 790 matching lines @@
 
 void WebGraphicsContext3DCommandBufferImpl::deleteShader(WebGLId shader) {
   gl_->DeleteShader(shader);
 }
 
 void WebGraphicsContext3DCommandBufferImpl::deleteTexture(WebGLId texture) {
   gl_->DeleteTextures(1, &texture);
 }
 
 void WebGraphicsContext3DCommandBufferImpl::OnSwapBuffersComplete() {
+  typedef WebGraphicsContext3DSwapBuffersClient WGC3DSwapClient;
   // This may be called after tear-down of the RenderView.
-  RenderViewImpl* renderview =
-      web_view_ ? RenderViewImpl::FromWebView(web_view_) : NULL;
-  if (renderview) {
-    MessageLoop::current()->PostTask(
-        FROM_HERE,
-        base::Bind(&RenderViewImpl::OnViewContextSwapBuffersComplete,
-                   renderview));
+  if (swap_client_.get()) {
+    MessageLoop::current()->PostTask(FROM_HERE, base::Bind(
+        &WGC3DSwapClient::OnViewContextSwapBuffersComplete, swap_client_));
   }
 
   if (swapbuffers_complete_callback_)
     swapbuffers_complete_callback_->onSwapBuffersComplete();
 }
 
 void WebGraphicsContext3DCommandBufferImpl::setContextLostCallback(
     WebGraphicsContext3D::WebGraphicsContextLostCallback* cb) {
   context_lost_callback_ = cb;
 }
@@ skipping 44 matching lines @@
 }  // anonymous namespace
 
 void WebGraphicsContext3DCommandBufferImpl::OnContextLost(
     RendererGLContext::ContextLostReason reason) {
   context_lost_reason_ = convertReason(reason);
   if (context_lost_callback_) {
     context_lost_callback_->onContextLost();
   }
   if (attributes_.shareResources)
     ClearSharedContexts();
-  RenderViewImpl* renderview =
-      web_view_ ? RenderViewImpl::FromWebView(web_view_) : NULL;
-  if (renderview)
-    renderview->OnViewContextSwapBuffersAborted();
+  if (swap_client_.get())
+    swap_client_->OnViewContextSwapBuffersAborted();
 }
-
-#endif  // defined(ENABLE_GPU)