aura: Remove CreateOffscreenContext from ui::ContextFactory.

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/memory/singleton.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/strings/string_util.h"
 #include "base/threading/thread.h"
 #include "base/threading/thread_restrictions.h"
 #include "cc/base/switches.h"
+#include "cc/debug/fake_context_provider.h"
 #include "cc/input/input_handler.h"
 #include "cc/layers/layer.h"
 #include "cc/output/context_provider.h"
 #include "cc/output/output_surface.h"
 #include "cc/trees/layer_tree_host.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "ui/compositor/compositor_observer.h"
 #include "ui/compositor/compositor_switches.h"
-#include "ui/compositor/context_provider_from_context_factory.h"
 #include "ui/compositor/dip_util.h"
 #include "ui/compositor/layer.h"
 #include "ui/compositor/reflector.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/common/gpu/context_provider_in_process.h"
 #include "webkit/common/gpu/grcontext_for_webgraphicscontext3d.h"
 #include "webkit/common/gpu/webgraphicscontext3d_in_process_command_buffer_impl.h"
 
 #if defined(OS_CHROMEOS)
 #include "base/chromeos/chromeos_version.h"
 #endif
 
 namespace {
 
 const double kDefaultRefreshRate = 60.0;
@@ skipping 55 matching lines @@
   if (!gfx::GLSurface::InitializeOneOff() ||
       gfx::GetGLImplementation() == gfx::kGLImplementationNone) {
     LOG(ERROR) << "Could not load the GL bindings";
     return false;
   }
   return true;
 }
 
 scoped_ptr<cc::OutputSurface> DefaultContextFactory::CreateOutputSurface(
     Compositor* compositor) {
-  return make_scoped_ptr(new cc::OutputSurface(
-      CreateContextCommon(compositor, false)));
-}
+  WebKit::WebGraphicsContext3D::Attributes attrs;
+  attrs.depth = false;
+  attrs.stencil = false;
+  attrs.antialias = false;
+  attrs.shareResources = true;
 
-scoped_ptr<WebKit::WebGraphicsContext3D>
-DefaultContextFactory::CreateOffscreenContext() {
-  return CreateContextCommon(NULL, true);
+  using webkit::gpu::WebGraphicsContext3DInProcessCommandBufferImpl;
+  scoped_ptr<WebKit::WebGraphicsContext3D> context(
+      WebGraphicsContext3DInProcessCommandBufferImpl::CreateViewContext(
+          attrs, compositor->widget()));
+  return make_scoped_ptr(new cc::OutputSurface(context.Pass()));
 }
 
 scoped_refptr<Reflector> DefaultContextFactory::CreateReflector(
     Compositor* mirroed_compositor,
     Layer* mirroring_layer) {
   return NULL;
 }
 
 void DefaultContextFactory::RemoveReflector(
     scoped_refptr<Reflector> reflector) {
 }
 
 scoped_refptr<cc::ContextProvider>
 DefaultContextFactory::OffscreenContextProviderForMainThread() {
   if (!offscreen_contexts_main_thread_.get() ||
       !offscreen_contexts_main_thread_->DestroyedOnMainThread()) {
     offscreen_contexts_main_thread_ =
-        ContextProviderFromContextFactory::CreateForOffscreen(this);
+        webkit::gpu::ContextProviderInProcess::Create();
     if (offscreen_contexts_main_thread_.get() &&
         !offscreen_contexts_main_thread_->BindToCurrentThread())
       offscreen_contexts_main_thread_ = NULL;
   }
   return offscreen_contexts_main_thread_;
 }
 
 scoped_refptr<cc::ContextProvider>
 DefaultContextFactory::OffscreenContextProviderForCompositorThread() {
   if (!offscreen_contexts_compositor_thread_.get() ||
       !offscreen_contexts_compositor_thread_->DestroyedOnMainThread()) {
     offscreen_contexts_compositor_thread_ =
-        ContextProviderFromContextFactory::CreateForOffscreen(this);
+        webkit::gpu::ContextProviderInProcess::Create();
   }
   return offscreen_contexts_compositor_thread_;
 }
 
 void DefaultContextFactory::RemoveCompositor(Compositor* compositor) {
 }
 
 bool DefaultContextFactory::DoesCreateTestContexts() { return false; }
 
-scoped_ptr<WebKit::WebGraphicsContext3D>
-DefaultContextFactory::CreateContextCommon(Compositor* compositor,
-                                           bool offscreen) {
-  DCHECK(offscreen || compositor);
-  WebKit::WebGraphicsContext3D::Attributes attrs;
-  attrs.depth = false;
-  attrs.stencil = false;
-  attrs.antialias = false;
-  attrs.shareResources = true;
-  using webkit::gpu::WebGraphicsContext3DInProcessCommandBufferImpl;
-  if (offscreen) {
-    return WebGraphicsContext3DInProcessCommandBufferImpl::
-        CreateOffscreenContext(attrs);
-  }
-  return WebGraphicsContext3DInProcessCommandBufferImpl::CreateViewContext(
-      attrs, compositor->widget());
-}
-
 TestContextFactory::TestContextFactory() {}
 
 TestContextFactory::~TestContextFactory() {}
 
 scoped_ptr<cc::OutputSurface> TestContextFactory::CreateOutputSurface(
     Compositor* compositor) {
   return make_scoped_ptr(new cc::OutputSurface(CreateOffscreenContext()));
 }
 
-scoped_ptr<WebKit::WebGraphicsContext3D>
-TestContextFactory::CreateOffscreenContext() {
-  scoped_ptr<ui::TestWebGraphicsContext3D> context(
-      new ui::TestWebGraphicsContext3D);
-  context->Initialize();
-  return context.PassAs<WebKit::WebGraphicsContext3D>();
-}
-
 scoped_refptr<Reflector> TestContextFactory::CreateReflector(
     Compositor* mirrored_compositor,
     Layer* mirroring_layer) {
   return new Reflector();
 }
 
 void TestContextFactory::RemoveReflector(scoped_refptr<Reflector> reflector) {
 }
 
 scoped_refptr<cc::ContextProvider>
 TestContextFactory::OffscreenContextProviderForMainThread() {
   if (!offscreen_contexts_main_thread_.get() ||
       offscreen_contexts_main_thread_->DestroyedOnMainThread()) {
-    offscreen_contexts_main_thread_ =
-        ContextProviderFromContextFactory::CreateForOffscreen(this);
+    offscreen_contexts_main_thread_ = cc::FakeContextProvider::Create(
+        base::Bind(&TestContextFactory::CreateOffscreenContext));
     CHECK(offscreen_contexts_main_thread_->BindToCurrentThread());
   }
   return offscreen_contexts_main_thread_;
 }
 
 scoped_refptr<cc::ContextProvider>
 TestContextFactory::OffscreenContextProviderForCompositorThread() {
   if (!offscreen_contexts_compositor_thread_.get() ||
       offscreen_contexts_compositor_thread_->DestroyedOnMainThread()) {
-    offscreen_contexts_compositor_thread_ =
-        ContextProviderFromContextFactory::CreateForOffscreen(this);
+    offscreen_contexts_compositor_thread_ = cc::FakeContextProvider::Create(
+        base::Bind(&TestContextFactory::CreateOffscreenContext));
   }
   return offscreen_contexts_compositor_thread_;
 }
 
 void TestContextFactory::RemoveCompositor(Compositor* compositor) {
 }
 
 bool TestContextFactory::DoesCreateTestContexts() { return true; }
 
+// static
+scoped_ptr<WebKit::WebGraphicsContext3D>
+TestContextFactory::CreateOffscreenContext() {
+  scoped_ptr<ui::TestWebGraphicsContext3D> context(
+      new ui::TestWebGraphicsContext3D);
+  context->Initialize();
+  return context.PassAs<WebKit::WebGraphicsContext3D>();
+}
+
 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 542 matching lines @@
 }
 
 void Compositor::NotifyEnd() {
   last_ended_frame_++;
   FOR_EACH_OBSERVER(CompositorObserver,
                     observer_list_,
                     OnCompositingEnded(this));
 }
 
 }  // namespace ui