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"
@@ skipping 11 matching lines @@
 #include "third_party/skia/include/core/SkBitmap.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/grcontext_for_webgraphicscontext3d.h"
 #include "webkit/gpu/webgraphicscontext3d_in_process_impl.h"
 
 #if defined(OS_CHROMEOS)
 #include "base/chromeos/chromeos_version.h"
 #endif
 
 namespace {
 
 const double kDefaultRefreshRate = 60.0;
 const double kTestRefreshRate = 100.0;
@@ skipping 92 matching lines @@
   g_context_factory = instance;
 }
 
 DefaultContextFactory::DefaultContextFactory() {
 }
 
 DefaultContextFactory::~DefaultContextFactory() {
 }
 
 bool DefaultContextFactory::Initialize() {
+  if (g_test_compositor_enabled)
+    return true;
+
   // The following line of code exists soley to disable IO restrictions
   // on this thread long enough to perform the GL bindings.
   // TODO(wjmaclean) Remove this when GL initialisation cleaned up.
   base::ThreadRestrictions::ScopedAllowIO allow_io;
   if (!gfx::GLSurface::InitializeOneOff() ||
       gfx::GetGLImplementation() == gfx::kGLImplementationNone) {
     LOG(ERROR) << "Could not load the GL bindings";
     return false;
   }
   return true;
 }
 
 cc::OutputSurface* DefaultContextFactory::CreateOutputSurface(
     Compositor* compositor) {
   return new WebGraphicsContextToOutputSurfaceAdapter(
       CreateContextCommon(compositor, false));
 }
 
 WebKit::WebGraphicsContext3D* DefaultContextFactory::CreateOffscreenContext() {
   return CreateContextCommon(NULL, true);
 }
 
+WebKit::WebGraphicsContext3D*
+DefaultContextFactory::OffscreenContextForMainThread() {
+  if (!test_offscreen_context_main_thread_) {
+    scoped_ptr<ui::TestWebGraphicsContext3D> test_context(

[piman, 2013/02/13 19:13:31]

Mmh, we should only be creating TestWGC3D-type contexts if
g_test_compositor_enabled is set. Otherwise in the general case, we'll be trying
to share fake texture/programs/... with a real context and bad things will
happen.

I'd rather have this always create a real context (through
CreateOffscreenContext for example), so that it's consistent, and have
Compositor decide which type of context based on g_test_compositor_enabled, like
it does for createOutputSurface.

[danakj, 2013/02/13 20:47:10]

The downside to this is that then we need storage in the compositor (or statics)
to hold the context3d because they need to persist across multiple calls to the
function.

I'll make them statics I guess since they shouldn't be per-compositor.

[piman, 2013/02/14 00:16:08]

Why couldn't they still be fields in DefaultContextFactory?

+        new ui::TestWebGraphicsContext3D());
+    test_context->Initialize();
+    test_offscreen_context_main_thread_ =
+        test_context.PassAs<WebKit::WebGraphicsContext3D>();
+  }
+  return test_offscreen_context_main_thread_.get();
+}
+
+WebKit::WebGraphicsContext3D*
+DefaultContextFactory::OffscreenContextForCompositorThread() {
+  if (!test_offscreen_context_compositor_thread_) {
+    scoped_ptr<ui::TestWebGraphicsContext3D> test_context(
+        new ui::TestWebGraphicsContext3D());
+    test_context->Initialize();
+    test_offscreen_context_compositor_thread_ =
+        test_context.PassAs<WebKit::WebGraphicsContext3D>();
+  }
+  return test_offscreen_context_compositor_thread_.get();
+}
+
+GrContext* DefaultContextFactory::OffscreenGrContextForMainThread() {
+  if (!grcontext_main_thread_ && test_offscreen_context_main_thread_) {
+    grcontext_main_thread_.reset(
+        new webkit::gpu::GrContextForWebGraphicsContext3D(
+            test_offscreen_context_main_thread_.get()));
+  }
+  return grcontext_main_thread_->gr_context();
+}
+
+GrContext* DefaultContextFactory::OffscreenGrContextForCompositorThread() {
+  if (!grcontext_compositor_thread_ &&
+      test_offscreen_context_compositor_thread_) {
+    grcontext_compositor_thread_.reset(
+        new webkit::gpu::GrContextForWebGraphicsContext3D(
+            test_offscreen_context_compositor_thread_.get()));
+  }
+  return grcontext_compositor_thread_->gr_context();
+}
+
+void DefaultContextFactory::DestroyOffscreenContext3dForCompositorThread() {
+  test_offscreen_context_compositor_thread_.reset();
+}
+
 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 338 matching lines @@
         new WebGraphicsContextToOutputSurfaceAdapter(test_context));
   } else {
     return scoped_ptr<cc::OutputSurface>(
         ContextFactory::GetInstance()->CreateOutputSurface(this));
   }
 }
 
 void Compositor::didRecreateOutputSurface(bool success) {
 }
 
+WebKit::WebGraphicsContext3D*
+Compositor::OffscreenContext3dForMainThread() {
+  return ContextFactory::GetInstance()->OffscreenContextForMainThread();
+}
+
+WebKit::WebGraphicsContext3D*
+Compositor::OffscreenContext3dForCompositorThread() {
+  return ContextFactory::GetInstance()->OffscreenContextForCompositorThread();
+}
+
+GrContext* Compositor::OffscreenGrContextForMainThread() {
+  return ContextFactory::GetInstance()->OffscreenGrContextForMainThread();
+}
+
+GrContext* Compositor::OffscreenGrContextForCompositorThread() {
+  return ContextFactory::GetInstance()->OffscreenGrContextForCompositorThread();
+}
+
+void Compositor::DestroyOffscreenContext3dForCompositorThread() {
+  ContextFactory::GetInstance()->DestroyOffscreenContext3dForCompositorThread();
+}
+
 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