Share shaders between browser compositors.

ui/gfx/compositor/compositor_gl.cc

 // Copyright (c) 2011 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/gfx/compositor/compositor_gl.h"
 
 #include "base/basictypes.h"
 #include "base/compiler_specific.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/threading/thread_restrictions.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "third_party/skia/include/core/SkMatrix.h"
 #include "third_party/skia/include/core/SkScalar.h"
 #include "ui/gfx/rect.h"
 #include "ui/gfx/transform.h"
 #include "ui/gfx/gl/gl_bindings.h"
 #include "ui/gfx/gl/gl_context.h"
 #include "ui/gfx/gl/gl_implementation.h"
 #include "ui/gfx/gl/gl_surface.h"
 
 namespace {
 
+// We pin the first context that the Compositor class creates with ref counting.
+// This hosts the shaders that are shared between all Compositor contexts.
+scoped_refptr<gfx::GLContext> g_share_context;
+
 GLuint CompileShader(GLenum type, const GLchar* source) {
   GLuint shader = glCreateShader(type);
   if (!shader)
     return 0;
 
   glShaderSource(shader, 1, &source, 0);
   glCompileShader(shader);
 
   GLint compiled;
   glGetShaderiv(shader, GL_COMPILE_STATUS, &compiled);
   if (!compiled) {
     GLint info_len = 0;
     glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &info_len);
 
     if (info_len > 0) {
       scoped_array<char> info_log(new char[info_len]);
       glGetShaderInfoLog(shader, info_len, NULL, info_log.get());
       LOG(ERROR) << "Compile error: " <<  info_log.get();
       return 0;
     }
   }
   return shader;
 }
 
 }  // namespace (anonymous)
 
 
 namespace ui {
 
+TextureProgramGL* CompositorGL::program_swizzle_ = NULL;
+TextureProgramGL* CompositorGL::program_no_swizzle_ = NULL;
+
 // Wraps a simple GL program for drawing textures to the screen.
 class TextureProgramGL {
  public:
   TextureProgramGL();
   virtual ~TextureProgramGL() {}
 
   // Returns false if it was unable to initialize properly.
   //
   // Host GL context must be current when this is called.
   virtual bool Initialize() = 0;
@@ skipping 22 matching lines @@
   GLuint frag_shader_;
 
  private:
   GLuint program_;
   GLuint vertex_shader_;
 
   GLuint a_pos_loc_;
   GLuint a_tex_loc_;
   GLuint u_tex_loc_;
   GLuint u_mat_loc_;
-
 };
 
 class TextureProgramNoSwizzleGL : public TextureProgramGL {
  public:
   TextureProgramNoSwizzleGL() {}
   virtual bool Initialize();
  private:
   DISALLOW_COPY_AND_ASSIGN(TextureProgramNoSwizzleGL);
 };
 
@@ skipping 207 matching lines @@
   glUniformMatrix4fv(program.u_mat_loc(), 1, GL_FALSE, m);
 
   glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
 }
 
 CompositorGL::CompositorGL(gfx::AcceleratedWidget widget,
                            const gfx::Size& size)
     : started_(false),
       size_(size) {
   gl_surface_ = gfx::GLSurface::CreateViewGLSurface(widget);
-  gl_context_ = gfx::GLContext::CreateGLContext(NULL, gl_surface_.get());
+  if (g_share_context.get()) {
+    gl_context_ = gfx::GLContext::CreateGLContext(
+        g_share_context->share_group(), gl_surface_.get());
+  } else {
+    gl_context_ = gfx::GLContext::CreateGLContext(
+        NULL, gl_surface_.get());
+    g_share_context = gl_context_;
+  }
   gl_context_->MakeCurrent(gl_surface_.get());
   if (!InitShaders())
     LOG(ERROR) << "Unable to initialize shaders (context = "
                << static_cast<void*>(gl_context_.get()) << ")";
   glColorMask(true, true, true, true);
   glEnable(GL_BLEND);
   glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
 }
 
 CompositorGL::~CompositorGL() {
 }
 
 void CompositorGL::MakeCurrent() {
   gl_context_->MakeCurrent(gl_surface_.get());
 }
 
 gfx::Size CompositorGL::GetSize() {
   return size_;
 }
 
 TextureProgramGL* CompositorGL::program_no_swizzle() {
-  return program_no_swizzle_.get();
+  return program_no_swizzle_;
 }
 
 TextureProgramGL* CompositorGL::program_swizzle() {
-  return program_swizzle_.get();
+  return program_swizzle_;
 }
 
 Texture* CompositorGL::CreateTexture() {
   Texture* texture = new TextureGL(this);
   return texture;
 }
 
 void CompositorGL::NotifyStart() {
   started_ = true;
   gl_context_->MakeCurrent(gl_surface_.get());
@@ skipping 25 matching lines @@
 void CompositorGL::SchedulePaint() {
   // TODO: X doesn't provide coalescing of regions, its left to the toolkit.
   NOTIMPLEMENTED();
 }
 
 void CompositorGL::OnWidgetSizeChanged(const gfx::Size& size) {
   size_ = size;
 }
 
 bool CompositorGL::InitShaders() {
-  scoped_ptr<TextureProgramGL> temp_program(new TextureProgramNoSwizzleGL());
-  if (!temp_program->Initialize())
-    return false;
-  else
-    program_no_swizzle_.reset(temp_program.release());
+  if (!program_no_swizzle_) {
+    scoped_ptr<TextureProgramGL> temp_program(new TextureProgramNoSwizzleGL());
+    if (!temp_program->Initialize())
+      return false;
+    program_no_swizzle_ = temp_program.release();
+  }
 
-  temp_program.reset(new TextureProgramSwizzleGL());
-  if (!temp_program->Initialize())
-    return false;
-  else
-    program_swizzle_.reset(temp_program.release());
+  if (!program_swizzle_) {
+    scoped_ptr<TextureProgramGL> temp_program(new TextureProgramSwizzleGL());
+    if (!temp_program->Initialize())
+      return false;
+    program_swizzle_ = temp_program.release();
+  }
 
   return true;
 }
 
 // static
 Compositor* Compositor::Create(gfx::AcceleratedWidget widget,
                                const gfx::Size& size) {
   // 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)
     return new CompositorGL(widget, size);
   return NULL;
 }
 
 }  // namespace ui