cc: Route offscreen context creation for compositor to the browser.

ui/compositor/compositor.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 "ui/compositor/compositor.h"
 
 #include <algorithm>
 #include <deque>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/message_loop.h"
 #include "base/string_util.h"
 #include "base/threading/thread.h"
 #include "base/threading/thread_restrictions.h"
 #include "cc/font_atlas.h"
 #include "cc/input_handler.h"
 #include "cc/layer.h"
 #include "cc/layer_tree_host.h"
 #include "cc/output_surface.h"
 #include "cc/thread_impl.h"
+#include "skia/ext/refptr.h"
 #include "third_party/skia/include/core/SkBitmap.h"
+#include "third_party/skia/include/gpu/GrContext.h"
+#include "third_party/skia/include/gpu/gl/GrGLInterface.h"
 #include "ui/compositor/compositor_observer.h"
 #include "ui/compositor/compositor_switches.h"
 #include "ui/compositor/dip_util.h"
 #include "ui/compositor/layer.h"
 #include "ui/compositor/test_web_graphics_context_3d.h"
 #include "ui/gl/gl_context.h"
 #include "ui/gl/gl_implementation.h"
 #include "ui/gl/gl_surface.h"
 #include "ui/gl/gl_switches.h"
 #include "webkit/gpu/webgraphicscontext3d_in_process_impl.h"
@@ skipping 123 matching lines @@
 cc::OutputSurface* DefaultContextFactory::CreateOutputSurface(
     Compositor* compositor) {
   return new WebGraphicsContextToOutputSurfaceAdapter(
       CreateContextCommon(compositor, false));
 }
 
 WebKit::WebGraphicsContext3D* DefaultContextFactory::CreateOffscreenContext() {
   return CreateContextCommon(NULL, true);
 }
 
+WebKit::WebGraphicsContext3D* DefaultContextFactory::
+    CreateOrGetOffscreenSkiaContextForMainThread() {
+  CreateOrGetOffscreenContextCommon(
+      &offscreen_skia_context_main_thread_,
+      &offscreen_skia_gr_context_main_thread_);
+  return offscreen_skia_context_main_thread_.get();
+}
+
+WebKit::WebGraphicsContext3D* DefaultContextFactory::
+    CreateOrGetOffscreenSkiaContextForCompositorThread() {
+  CreateOrGetOffscreenContextCommon(
+      &offscreen_skia_context_compositor_thread_,
+      &offscreen_skia_gr_context_compositor_thread_);
+  return offscreen_skia_context_compositor_thread_.get();
+}
+
+GrContext* DefaultContextFactory::
+    CreateOrGetOffscreenSkiaGrContextForMainThread() {
+  CreateOrGetOffscreenSkiaContextForMainThread();
+  if (!offscreen_skia_context_main_thread_)
+    return NULL;
+
+  if (!offscreen_skia_gr_context_main_thread_) {
+    skia::RefPtr<GrGLInterface> interface = skia::AdoptRef(
+        offscreen_skia_context_main_thread_->createGrGLInterface());
+    offscreen_skia_gr_context_main_thread_ = skia::AdoptRef(GrContext::Create(
+        kOpenGL_Shaders_GrEngine,
+        reinterpret_cast<GrPlatform3DContext>(interface.get())));
+  }
+  return offscreen_skia_gr_context_main_thread_.get();
+}
+
+GrContext* DefaultContextFactory::
+    CreateOrGetOffscreenSkiaGrContextForCompositorThread() {
+  CreateOrGetOffscreenSkiaContextForCompositorThread();
+  if (!offscreen_skia_context_compositor_thread_)
+    return NULL;
+
+  if (!offscreen_skia_gr_context_compositor_thread_) {
+    skia::RefPtr<GrGLInterface> interface = skia::AdoptRef(
+        offscreen_skia_context_compositor_thread_->createGrGLInterface());
+    offscreen_skia_gr_context_compositor_thread_ =
+        skia::AdoptRef(GrContext::Create(
+            kOpenGL_Shaders_GrEngine,
+            reinterpret_cast<GrPlatform3DContext>(interface.get())));
+  }
+  return offscreen_skia_gr_context_compositor_thread_.get();
+}
+
 void DefaultContextFactory::RemoveCompositor(Compositor* compositor) {
 }
 
 WebKit::WebGraphicsContext3D* DefaultContextFactory::CreateContextCommon(
     Compositor* compositor,
     bool offscreen) {
   DCHECK(offscreen || compositor);
   WebKit::WebGraphicsContext3D::Attributes attrs;
   attrs.depth = false;
   attrs.stencil = false;
@@ skipping 12 matching lines @@
   if (!offscreen) {
     context->makeContextCurrent();
     gfx::GLContext* gl_context = gfx::GLContext::GetCurrent();
     bool vsync = !command_line->HasSwitch(switches::kDisableGpuVsync);
     gl_context->SetSwapInterval(vsync ? 1 : 0);
     gl_context->ReleaseCurrent(NULL);
   }
   return context;
 }
 
+void DefaultContextFactory::CreateOrGetOffscreenContextCommon(
+    scoped_ptr<WebKit::WebGraphicsContext3D>* context3d,
+    skia::RefPtr<GrContext>* gr_context) {
+  if ((*context3d)) {
+    if (!(*context3d)->makeContextCurrent() ||
+        (*context3d)->getGraphicsResetStatusARB()) {
+      if ((*gr_context))
+        (*gr_context)->contextDestroyed();
+      gr_context->clear();
+      context3d->reset();
+    }
+  }
+
+  if (!(*context3d))
+    (*context3d) = make_scoped_ptr(CreateOffscreenContext());
+}
+
 Texture::Texture(bool flipped, const gfx::Size& size, float device_scale_factor)
     : size_(size),
       flipped_(flipped),
       device_scale_factor_(device_scale_factor) {
 }
 
 Texture::~Texture() {
 }
 
 std::string Texture::Produce() {
@@ skipping 306 matching lines @@
         new WebGraphicsContextToOutputSurfaceAdapter(test_context));
   } else {
     return scoped_ptr<cc::OutputSurface>(
         ContextFactory::GetInstance()->CreateOutputSurface(this));
   }
 }
 
 void Compositor::didRecreateOutputSurface(bool success) {
 }
 
+WebKit::WebGraphicsContext3D*
+    Compositor::createOrGetOffscreenContext3dForMainThread() {
+  return ContextFactory::GetInstance()->
+      CreateOrGetOffscreenSkiaContextForMainThread();
+}
+
+WebKit::WebGraphicsContext3D*
+    Compositor::createOrGetOffscreenContext3dForCompositorThread() {
+  return ContextFactory::GetInstance()->
+      CreateOrGetOffscreenSkiaContextForCompositorThread();
+}
+
+GrContext* Compositor::createOrGetOffscreenGrContextForMainThread() {
+  return ContextFactory::GetInstance()->
+      CreateOrGetOffscreenSkiaGrContextForMainThread();
+}
+
+GrContext* Compositor::createOrGetOffscreenGrContextForCompositorThread() {
+  return ContextFactory::GetInstance()->
+      CreateOrGetOffscreenSkiaGrContextForCompositorThread();
+}
+
 scoped_ptr<cc::InputHandler> Compositor::createInputHandler() {
   return scoped_ptr<cc::InputHandler>();
 }
 
 void Compositor::willCommit() {
 }
 
 void Compositor::didCommit() {
   DCHECK(!IsLocked());
   FOR_EACH_OBSERVER(CompositorObserver,
@@ skipping 70 matching lines @@
 
 COMPOSITOR_EXPORT void DisableTestCompositor() {
   g_test_compositor_enabled = false;
 }
 
 COMPOSITOR_EXPORT bool IsTestCompositorEnabled() {
   return g_test_compositor_enabled;
 }
 
 }  // namespace ui