Vend common GL context

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"
@@ skipping 66 matching lines @@
 };
 
 class TextureProgramSwizzleGL : public ui::TextureProgramGL {
  public:
   TextureProgramSwizzleGL() {}
   virtual bool Initialize();
  private:
   DISALLOW_COPY_AND_ASSIGN(TextureProgramSwizzleGL);
 };
 
-// We share between compositor contexts so that we don't have to compile
-// shaders if they have already been compiled in another context.
-class SharedResources {
- public:
-  static SharedResources* GetInstance();
-
-  // Creates a context with shaders active.
-  scoped_refptr<gfx::GLContext> CreateContext(gfx::GLSurface* surface);
-  void ContextDestroyed();
-
-  ui::TextureProgramGL* program_no_swizzle() {
-    return program_no_swizzle_.get();
-  }
-
-  ui::TextureProgramGL* program_swizzle() { return program_swizzle_.get(); }
-
- private:
-  friend struct DefaultSingletonTraits<SharedResources>;
-
-  SharedResources();
-  virtual ~SharedResources();
-
-  scoped_refptr<gfx::GLShareGroup> share_group_;
-  scoped_ptr<ui::TextureProgramGL> program_swizzle_;
-  scoped_ptr<ui::TextureProgramGL> program_no_swizzle_;
-
-  DISALLOW_COPY_AND_ASSIGN(SharedResources);
-};
-
 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);
@@ skipping 42 matching lines @@
       "  gl_FragColor = texture2D(u_tex, v_texCoord).zyxw;"
       "}";
 
   frag_shader_ = CompileShader(GL_FRAGMENT_SHADER, frag_shader_source);
   if (!frag_shader_)
     return false;
 
   return InitializeCommon();
 }
 
-SharedResources::SharedResources() {
-}
-
-SharedResources::~SharedResources() {
-}
-
-// static
-SharedResources* SharedResources::GetInstance() {
-  return Singleton<SharedResources>::get();
-}
-
-scoped_refptr<gfx::GLContext> SharedResources::CreateContext(
-    gfx::GLSurface* surface) {
-  if (share_group_.get()) {
-    return gfx::GLContext::CreateGLContext(share_group_.get(), surface);
-  } else {
-    scoped_refptr<gfx::GLContext> context(
-        gfx::GLContext::CreateGLContext(NULL, surface));
-    context->MakeCurrent(surface);
-
-    if (!program_no_swizzle_.get()) {
-      scoped_ptr<ui::TextureProgramGL> temp_program(
-          new TextureProgramNoSwizzleGL());
-      if (!temp_program->Initialize()) {
-        LOG(ERROR) << "Unable to initialize shaders (context = "
-                   << static_cast<void*>(context.get()) << ")";
-        return NULL;
-      }
-      program_no_swizzle_.swap(temp_program);
-    }
-
-    if (!program_swizzle_.get()) {
-      scoped_ptr<ui::TextureProgramGL> temp_program(
-          new TextureProgramSwizzleGL());
-      if (!temp_program->Initialize()) {
-        LOG(ERROR) << "Unable to initialize shaders (context = "
-                   << static_cast<void*>(context.get()) << ")";
-        return NULL;
-      }
-      program_swizzle_.swap(temp_program);
-    }
-
-    share_group_ = context->share_group();
-    return context;
-  }
-}
-
-void SharedResources::ContextDestroyed() {
-  if (share_group_.get() && share_group_->GetHandle() == NULL) {
-    share_group_ = NULL;
-    program_no_swizzle_.reset();
-    program_swizzle_.reset();
-  }
-}
-
 }  // namespace
 
 namespace ui {
 
 TextureProgramGL::TextureProgramGL()
     : program_(0),
       a_pos_loc_(0),
       a_tex_loc_(0),
       u_tex_loc_(0),
       u_mat_loc_(0) {
@@ skipping 25 matching lines @@
 
   // Store locations of program inputs.
   a_pos_loc_ = glGetAttribLocation(program_, "a_position");
   a_tex_loc_ = glGetAttribLocation(program_, "a_texCoord");
   u_tex_loc_ = glGetUniformLocation(program_, "u_tex");
   u_mat_loc_ = glGetUniformLocation(program_, "u_matViewProjection");
 
   return true;
 }
 
-TextureGL::TextureGL(CompositorGL* compositor) : texture_id_(0),
-                                                 compositor_(compositor) {
+SharedResources::SharedResources() : initialized_(false) {
 }
 
-TextureGL::TextureGL(CompositorGL* compositor,
-                     const gfx::Size& size)
-    : texture_id_(0),
-      size_(size),
-      compositor_(compositor) {
+
+SharedResources::~SharedResources() {
+}
+
+// static
+SharedResources* SharedResources::GetInstance() {
+  // We use LeakySingletonTraits so that we don't race with
+  // the tear down of the gl_bindings.
+  SharedResources* instance = Singleton<SharedResources,
+      LeakySingletonTraits<SharedResources> >::get();
+  if (instance->Initialize()) {
+    return instance;
+  } else {
+    instance->Destroy();
+    return NULL;
+  }
+}
+
+bool SharedResources::Initialize() {
+  if (initialized_)
+    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;
+    }
+  }
+
+  surface_ = gfx::GLSurface::CreateOffscreenGLSurface(false, gfx::Size(1, 1));
+  if (!surface_.get()) {
+    LOG(ERROR) << "Unable to create offscreen GL surface.";
+    return false;
+  }
+
+  context_ = gfx::GLContext::CreateGLContext(NULL, surface_.get());
+  if (!context_.get()) {
+    LOG(ERROR) << "Unable to create GL context.";
+    return false;
+  }
+
+  program_no_swizzle_.reset();
+  program_swizzle_.reset();
+
+  context_->MakeCurrent(surface_.get());
+
+  scoped_ptr<ui::TextureProgramGL> temp_program_no_swizzle(
+      new TextureProgramNoSwizzleGL());
+  if (!temp_program_no_swizzle->Initialize()) {
+    LOG(ERROR) << "Unable to initialize shader.";
+    return false;
+  }
+
+  scoped_ptr<ui::TextureProgramGL> temp_program_swizzle(
+      new TextureProgramSwizzleGL());
+  if (!temp_program_swizzle->Initialize()) {
+    LOG(ERROR) << "Unable to initialize shader.";
+    return false;
+  }
+
+  program_no_swizzle_.swap(temp_program_no_swizzle);
+  program_swizzle_.swap(temp_program_swizzle);
+
+  initialized_ = true;
+  return true;
+}
+
+void SharedResources::Destroy() {
+  program_swizzle_.reset();
+  program_no_swizzle_.reset();
+
+  context_ = NULL;
+  surface_ = NULL;
+
+  initialized_ = false;
+}
+
+bool SharedResources::MakeSharedContextCurrent() {
+  if (!initialized_)
+    return false;
+  else
+    return context_->MakeCurrent(surface_.get());
+}
+
+scoped_refptr<gfx::GLContext> SharedResources::CreateContext(
+    gfx::GLSurface* surface) {
+  if (initialized_)
+    return gfx::GLContext::CreateGLContext(context_->share_group(), surface);
+  else
+    return NULL;
+}
+
+TextureGL::TextureGL() : texture_id_(0) {
+}
+
+TextureGL::TextureGL(const gfx::Size& size) : texture_id_(0), size_(size) {
 }
 
 TextureGL::~TextureGL() {
   if (texture_id_) {
-    compositor_->MakeCurrent();
+    SharedResources* instance = SharedResources::GetInstance();
+    DCHECK(instance);
+    instance->MakeSharedContextCurrent();
     glDeleteTextures(1, &texture_id_);
   }
 }
 
 void TextureGL::SetCanvas(const SkCanvas& canvas,
                           const gfx::Point& origin,
                           const gfx::Size& overall_size) {
   const SkBitmap& bitmap = canvas.getDevice()->accessBitmap(false);
   // Verify bitmap pixels are contiguous.
   DCHECK_EQ(bitmap.rowBytes(),
@@ skipping 24 matching lines @@
                  GL_RGBA, GL_UNSIGNED_BYTE, pixels);
   } else {  // Uploading partial texture.
     glBindTexture(GL_TEXTURE_2D, texture_id_);
     glTexSubImage2D(GL_TEXTURE_2D, 0, origin.x(), origin.y(),
                     bitmap.width(), bitmap.height(),
                     GL_RGBA, GL_UNSIGNED_BYTE, pixels);
   }
 }
 
 void TextureGL::Draw(const ui::TextureDrawParams& params) {
-  DCHECK(compositor_->program_swizzle());
   Draw(params, gfx::Rect(0, 0, size_.width(), size_.height()));
 }
 
 void TextureGL::Draw(const ui::TextureDrawParams& params,
                      const gfx::Rect& clip_bounds_in_texture) {
-  DCHECK(compositor_->program_swizzle());
-  DrawInternal(*compositor_->program_swizzle(), params, clip_bounds_in_texture);
+  SharedResources* instance = SharedResources::GetInstance();
+  DCHECK(instance);
+  DrawInternal(*instance->program_swizzle(),
+               params,
+               clip_bounds_in_texture);
 }
+
 void TextureGL::DrawInternal(const ui::TextureProgramGL& program,
                              const ui::TextureDrawParams& params,
                              const gfx::Rect& clip_bounds_in_texture) {
-   // clip clip_bounds_in_layer to size of texture
-   gfx::Rect clip_bounds = clip_bounds_in_texture.Intersect(
-       gfx::Rect(gfx::Point(0, 0), size_));
+  // Clip clip_bounds_in_texture to size of texture.
+  gfx::Rect clip_bounds = clip_bounds_in_texture.Intersect(
+      gfx::Rect(gfx::Point(0, 0), size_));
+
+  // Verify that compositor_size has been set.
+  DCHECK(params.compositor_size != gfx::Size(0,0));
 
   if (params.blend)
     glEnable(GL_BLEND);
   else
     glDisable(GL_BLEND);
 
   program.Use();
 
   glActiveTexture(GL_TEXTURE0);
   glUniform1i(program.u_tex_loc(), 0);
   glBindTexture(GL_TEXTURE_2D, texture_id_);
 
-  gfx::Size window_size = compositor_->GetSize();
-
   ui::Transform t;
   t.ConcatTranslate(1, 1);
   t.ConcatScale(size_.width()/2.0f, size_.height()/2.0f);
   t.ConcatTranslate(0, -size_.height());
   t.ConcatScale(1, -1);
 
   t.ConcatTransform(params.transform);  // Add view transform.
 
-  t.ConcatTranslate(0, -window_size.height());
+  t.ConcatTranslate(0, -params.compositor_size.height());
   t.ConcatScale(1, -1);
-  t.ConcatTranslate(-window_size.width() / 2.0f, -window_size.height() / 2.0f);
-  t.ConcatScale(2.0f / window_size.width(), 2.0f / window_size.height());
+  t.ConcatTranslate(-params.compositor_size.width() / 2.0f,
+                    -params.compositor_size.height() / 2.0f);
+  t.ConcatScale(2.0f / params.compositor_size.width(),
+                2.0f / params.compositor_size.height());
 
   GLfloat m[16];
   t.matrix().asColMajorf(m);
 
-  // TODO(pkotwicz) window_size != size_, fix this
   SkRect texture_rect = SkRect::MakeXYWH(
       clip_bounds.x(),
       clip_bounds.y(),
       clip_bounds.width(),
       clip_bounds.height());
 
   ui::Transform texture_rect_transform;
   texture_rect_transform.ConcatScale(1.0f / size_.width(),
                                      1.0f / size_.height());
   SkMatrix texture_transform_matrix = texture_rect_transform.matrix();
@@ skipping 30 matching lines @@
   glEnableVertexAttribArray(program.a_pos_loc());
   glEnableVertexAttribArray(program.a_tex_loc());
 
   glUniformMatrix4fv(program.u_mat_loc(), 1, GL_FALSE, m);
 
   glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
 }
 
 CompositorGL::CompositorGL(gfx::AcceleratedWidget widget,
                            const gfx::Size& size)
-    : size_(size),
+    : Compositor(size),
       started_(false) {
   gl_surface_ = gfx::GLSurface::CreateViewGLSurface(false, widget);
   gl_context_ = SharedResources::GetInstance()->
       CreateContext(gl_surface_.get());
   gl_context_->MakeCurrent(gl_surface_.get());
   glColorMask(true, true, true, true);
   glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
 }
 
 CompositorGL::~CompositorGL() {
   gl_context_ = NULL;
-  SharedResources::GetInstance()->ContextDestroyed();
 }
 
 void CompositorGL::MakeCurrent() {
   gl_context_->MakeCurrent(gl_surface_.get());
 }
 
-gfx::Size CompositorGL::GetSize() {
-  return size_;
-}
-
-TextureProgramGL* CompositorGL::program_no_swizzle() {
-  return SharedResources::GetInstance()->program_no_swizzle();
-}
-
-TextureProgramGL* CompositorGL::program_swizzle() {
-  return SharedResources::GetInstance()->program_swizzle();
+void CompositorGL::OnWidgetSizeChanged() {
 }
 
 Texture* CompositorGL::CreateTexture() {
-  Texture* texture = new TextureGL(this);
+  Texture* texture = new TextureGL();
   return texture;
 }
 
 void CompositorGL::NotifyStart() {
   started_ = true;
   gl_context_->MakeCurrent(gl_surface_.get());
-  glViewport(0, 0, size_.width(), size_.height());
+  glViewport(0, 0, size().width(), size().height());
   glColorMask(true, true, true, true);
 
 #if defined(DEBUG)
   // Clear to 'psychedelic' purple to make it easy to spot un-rendered regions.
   glClearColor(223.0 / 255, 0, 1, 1);
   glClear(GL_COLOR_BUFFER_BIT);
 #endif
   // Do not clear in release: root layer is responsible for drawing every pixel.
 }
 
 void CompositorGL::NotifyEnd() {
   DCHECK(started_);
   gl_surface_->SwapBuffers();
   started_ = false;
 }
 
 void CompositorGL::Blur(const gfx::Rect& bounds) {
   NOTIMPLEMENTED();
 }
 
 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;
-}
-
 // 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)
+  if (SharedResources::GetInstance() == NULL)
+    return NULL;
+  else
     return new CompositorGL(widget, size);
-  return NULL;
 }
 
 }  // namespace ui