aura: Remove CreateOffscreenContext from ui::ContextFactory.

ui/compositor/compositor.h

 // 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.
 
 #ifndef UI_COMPOSITOR_COMPOSITOR_H_
 #define UI_COMPOSITOR_COMPOSITOR_H_
 
 #include <string>
 
 #include "base/containers/hash_tables.h"
@@ skipping 13 matching lines @@
 
 class SkBitmap;
 
 namespace base {
 class MessageLoopProxy;
 class RunLoop;
 }
 
 namespace cc {
 class ContextProvider;
+class FakeContextProvider;
 class Layer;
 class LayerTreeDebugState;
 class LayerTreeHost;
 }
 
 namespace gfx {
 class GLContext;
 class GLSurface;
 class GLShareGroup;
 class Point;
 class Rect;
 class Size;
 }
 
 namespace WebKit {
 class WebGraphicsContext3D;
 }
 
+namespace webkit {
+namespace gpu {
+class ContextProviderInProcess;
+}
+}
+
 namespace ui {
 
 class Compositor;
 class CompositorObserver;
 class ContextProviderFromContextFactory;
 class Layer;
 class PostedSwapQueue;
 class Reflector;
 class Texture;
 struct LatencyInfo;
@@ skipping 11 matching lines @@
   // If this function isn't called (for tests), a "default" factory will be
   // created on the first call of GetInstance.
   static void SetInstance(ContextFactory* instance);
 
   // Creates an output surface for the given compositor. The factory may keep
   // per-compositor data (e.g. a shared context), that needs to be cleaned up
   // by calling RemoveCompositor when the compositor gets destroyed.
   virtual scoped_ptr<cc::OutputSurface> CreateOutputSurface(
       Compositor* compositor) = 0;
 
-  // Creates a context used for offscreen rendering. This context can be shared
-  // with all compositors.
-  virtual scoped_ptr<WebKit::WebGraphicsContext3D> CreateOffscreenContext() = 0;
-
   // Creates a reflector that copies the content of the |mirrored_compositor|
   // onto |mirroing_layer|.
   virtual scoped_refptr<Reflector> CreateReflector(
       Compositor* mirrored_compositor,
       Layer* mirroring_layer) = 0;
   // Removes the reflector, which stops the mirroring.
   virtual void RemoveReflector(scoped_refptr<Reflector> reflector) = 0;
 
   virtual scoped_refptr<cc::ContextProvider>
       OffscreenContextProviderForMainThread() = 0;
@@ skipping 10 matching lines @@
 
 // The default factory that creates in-process contexts.
 class COMPOSITOR_EXPORT DefaultContextFactory : public ContextFactory {
  public:
   DefaultContextFactory();
   virtual ~DefaultContextFactory();
 
   // ContextFactory implementation
   virtual scoped_ptr<cc::OutputSurface> CreateOutputSurface(
       Compositor* compositor) OVERRIDE;
-  virtual scoped_ptr<WebKit::WebGraphicsContext3D> CreateOffscreenContext()
-      OVERRIDE;
 
   virtual scoped_refptr<Reflector> CreateReflector(
       Compositor* compositor,
       Layer* layer) OVERRIDE;
   virtual void RemoveReflector(scoped_refptr<Reflector> reflector) OVERRIDE;
 
   virtual scoped_refptr<cc::ContextProvider>
       OffscreenContextProviderForMainThread() OVERRIDE;
   virtual scoped_refptr<cc::ContextProvider>
       OffscreenContextProviderForCompositorThread() OVERRIDE;
   virtual void RemoveCompositor(Compositor* compositor) OVERRIDE;
   virtual bool DoesCreateTestContexts() OVERRIDE;
 
   bool Initialize();
 
  private:
-  scoped_ptr<WebKit::WebGraphicsContext3D> CreateContextCommon(
-      Compositor* compositor,
-      bool offscreen);
-
-  scoped_refptr<ContextProviderFromContextFactory>
+  scoped_refptr<webkit::gpu::ContextProviderInProcess>
       offscreen_contexts_main_thread_;
-  scoped_refptr<ContextProviderFromContextFactory>
+  scoped_refptr<webkit::gpu::ContextProviderInProcess>
       offscreen_contexts_compositor_thread_;
 
   DISALLOW_COPY_AND_ASSIGN(DefaultContextFactory);
 };
 
 // The factory that creates test contexts.
 class COMPOSITOR_EXPORT TestContextFactory : public ContextFactory {
  public:
   TestContextFactory();
   virtual ~TestContextFactory();
 
   // ContextFactory implementation
   virtual scoped_ptr<cc::OutputSurface> CreateOutputSurface(
       Compositor* compositor) OVERRIDE;
-  virtual scoped_ptr<WebKit::WebGraphicsContext3D> CreateOffscreenContext()
-      OVERRIDE;
 
   virtual scoped_refptr<Reflector> CreateReflector(
       Compositor* mirrored_compositor,
       Layer* mirroring_layer) OVERRIDE;
   virtual void RemoveReflector(scoped_refptr<Reflector> reflector) OVERRIDE;
 
   virtual scoped_refptr<cc::ContextProvider>
       OffscreenContextProviderForMainThread() OVERRIDE;
   virtual scoped_refptr<cc::ContextProvider>
       OffscreenContextProviderForCompositorThread() OVERRIDE;
   virtual void RemoveCompositor(Compositor* compositor) OVERRIDE;
   virtual bool DoesCreateTestContexts() OVERRIDE;
 
  private:
-  scoped_refptr<ContextProviderFromContextFactory>
-      offscreen_contexts_main_thread_;
-  scoped_refptr<ContextProviderFromContextFactory>
-      offscreen_contexts_compositor_thread_;
+  static scoped_ptr<WebKit::WebGraphicsContext3D> CreateOffscreenContext();
+
+  scoped_refptr<cc::FakeContextProvider> offscreen_contexts_main_thread_;
+  scoped_refptr<cc::ContextProvider> offscreen_contexts_compositor_thread_;
 
   DISALLOW_COPY_AND_ASSIGN(TestContextFactory);
 };
 
 // Texture provide an abstraction over the external texture that can be passed
 // to a layer.
 class COMPOSITOR_EXPORT Texture : public base::RefCounted<Texture> {
  public:
   Texture(bool flipped, const gfx::Size& size, float device_scale_factor);
 
@@ skipping 269 matching lines @@
   bool disable_schedule_composite_;
 
   CompositorLock* compositor_lock_;
 
   DISALLOW_COPY_AND_ASSIGN(Compositor);
 };
 
 }  // namespace ui
 
 #endif  // UI_COMPOSITOR_COMPOSITOR_H_