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

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 "base/hash_tables.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/observer_list.h"
 #include "cc/layer_tree_host_client.h"
+#include "skia/ext/refptr.h"
 #include "ui/compositor/compositor_export.h"
 #include "ui/gfx/native_widget_types.h"
 #include "ui/gfx/size.h"
 #include "ui/gfx/transform.h"
 #include "ui/gl/gl_share_group.h"
 
 class SkBitmap;
 
 namespace cc {
 class FontAtlas;
@@ skipping 37 matching lines @@
   // 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 cc::OutputSurface* CreateOutputSurface(
       Compositor* compositor) = 0;
 
   // Creates a context used for offscreen rendering. This context can be shared
   // with all compositors.
   virtual WebKit::WebGraphicsContext3D* CreateOffscreenContext() = 0;
 
+  virtual WebKit::WebGraphicsContext3D*
+      CreateOrGetOffscreenSkiaContextForMainThread() = 0;
+  virtual WebKit::WebGraphicsContext3D*
+      CreateOrGetOffscreenSkiaContextForCompositorThread() = 0;
+  virtual GrContext*
+      CreateOrGetOffscreenSkiaGrContextForMainThread() = 0;
+  virtual GrContext*
+      CreateOrGetOffscreenSkiaGrContextForCompositorThread() = 0;
+
   // Destroys per-compositor data.
   virtual void RemoveCompositor(Compositor* compositor) = 0;
 };
 
 // The default factory that creates in-process contexts.
 class COMPOSITOR_EXPORT DefaultContextFactory : public ContextFactory {
  public:
   DefaultContextFactory();
   virtual ~DefaultContextFactory();
 
   // ContextFactory implementation
   virtual cc::OutputSurface* CreateOutputSurface(
       Compositor* compositor) OVERRIDE;
   virtual WebKit::WebGraphicsContext3D* CreateOffscreenContext() OVERRIDE;
+  virtual WebKit::WebGraphicsContext3D*
+      CreateOrGetOffscreenSkiaContextForMainThread() OVERRIDE;
+  virtual WebKit::WebGraphicsContext3D*
+      CreateOrGetOffscreenSkiaContextForCompositorThread() OVERRIDE;
+  virtual GrContext*
+      CreateOrGetOffscreenSkiaGrContextForMainThread() OVERRIDE;
+  virtual GrContext*
+      CreateOrGetOffscreenSkiaGrContextForCompositorThread() OVERRIDE;
   virtual void RemoveCompositor(Compositor* compositor) OVERRIDE;
 
   bool Initialize();
 
   void set_share_group(gfx::GLShareGroup* share_group) {
     share_group_ = share_group;
   }
 
  private:
   WebKit::WebGraphicsContext3D* CreateContextCommon(
       Compositor* compositor,
       bool offscreen);
 
+  void CreateOrGetOffscreenContextCommon(
+      scoped_ptr<WebKit::WebGraphicsContext3D>* context3d,
+      skia::RefPtr<GrContext>* gr_context);
+
   scoped_refptr<gfx::GLShareGroup> share_group_;
+  scoped_ptr<WebKit::WebGraphicsContext3D> offscreen_skia_context_main_thread_;
+  scoped_ptr<WebKit::WebGraphicsContext3D>
+      offscreen_skia_context_compositor_thread_;
+  skia::RefPtr<GrContext> offscreen_skia_gr_context_main_thread_;
+  skia::RefPtr<GrContext> offscreen_skia_gr_context_compositor_thread_;
 
   DISALLOW_COPY_AND_ASSIGN(DefaultContextFactory);
 };
 
 // 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 146 matching lines @@
   // LayerTreeHostClient implementation.
   virtual void willBeginFrame() OVERRIDE;
   virtual void didBeginFrame() OVERRIDE;
   virtual void animate(double frameBeginTime) OVERRIDE;
   virtual void layout() OVERRIDE;
   virtual void applyScrollAndScale(gfx::Vector2d scrollDelta,
                                    float pageScale) OVERRIDE;
   virtual scoped_ptr<cc::OutputSurface>
       createOutputSurface() OVERRIDE;
   virtual void didRecreateOutputSurface(bool success) OVERRIDE;
+  virtual WebKit::WebGraphicsContext3D*
+      createOrGetOffscreenContext3dForMainThread() OVERRIDE;
+  virtual WebKit::WebGraphicsContext3D*
+      createOrGetOffscreenContext3dForCompositorThread() OVERRIDE;
+  virtual GrContext* createOrGetOffscreenGrContextForMainThread() OVERRIDE;
+  virtual GrContext* createOrGetOffscreenGrContextForCompositorThread()
+      OVERRIDE;
   virtual scoped_ptr<cc::InputHandler> createInputHandler() OVERRIDE;
   virtual void willCommit() OVERRIDE;
   virtual void didCommit() OVERRIDE;
   virtual void didCommitAndDrawFrame() OVERRIDE;
   virtual void didCompleteSwapBuffers() OVERRIDE;
   virtual void scheduleComposite() OVERRIDE;
   virtual scoped_ptr<cc::FontAtlas> createFontAtlas() OVERRIDE;
 
 
   int last_started_frame() { return last_started_frame_; }
@@ skipping 39 matching lines @@
   bool disable_schedule_composite_;
 
   CompositorLock* compositor_lock_;
 
   DISALLOW_COPY_AND_ASSIGN(Compositor);
 };
 
 }  // namespace ui
 
 #endif  // UI_COMPOSITOR_COMPOSITOR_H_