Enable accelerated compositing of web pages when using webkit compositor

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 190 matching lines @@
   // Store locations of program inputs.
   a_pos_loc_ = glGetAttribLocation(program_, "a_position");
   a_tex_loc_ = glGetAttribLocation(program_, "a_texCoord");
   u_alpha_loc_ = glGetUniformLocation(program_, "u_alpha");
   u_tex_loc_ = glGetUniformLocation(program_, "u_tex");
   u_mat_loc_ = glGetUniformLocation(program_, "u_matViewProjection");
 
   return true;
 }
 
-SharedResources::SharedResources() : initialized_(false) {
+SharedResourcesGL::SharedResourcesGL() : initialized_(false) {
 }
 
 
-SharedResources::~SharedResources() {
+SharedResourcesGL::~SharedResourcesGL() {
 }
 
 // static
-SharedResources* SharedResources::GetInstance() {
+SharedResourcesGL* SharedResourcesGL::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();
+  SharedResourcesGL* instance = Singleton<SharedResourcesGL,
+      LeakySingletonTraits<SharedResourcesGL> >::get();
   if (instance->Initialize()) {
     return instance;
   } else {
     instance->Destroy();
     return NULL;
   }
 }
 
-bool SharedResources::Initialize() {
+bool SharedResourcesGL::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) {
@@ skipping 36 matching lines @@
     return false;
   }
 
   program_no_swizzle_.swap(temp_program_no_swizzle);
   program_swizzle_.swap(temp_program_swizzle);
 
   initialized_ = true;
   return true;
 }
 
-void SharedResources::Destroy() {
+void SharedResourcesGL::Destroy() {
   program_swizzle_.reset();
   program_no_swizzle_.reset();
 
   context_ = NULL;
   surface_ = NULL;
 
   initialized_ = false;
 }
 
-bool SharedResources::MakeSharedContextCurrent() {
+bool SharedResourcesGL::MakeSharedContextCurrent() {
   if (!initialized_)
     return false;
   else
     return context_->MakeCurrent(surface_.get());
 }
 
-scoped_refptr<gfx::GLContext> SharedResources::CreateContext(
+scoped_refptr<gfx::GLContext> SharedResourcesGL::CreateContext(
     gfx::GLSurface* surface) {
   if (initialized_)
     return gfx::GLContext::CreateGLContext(
         context_->share_group(),
         surface,
         gfx::PreferIntegratedGpu);
   else
     return NULL;
 }
 
 TextureGL::TextureGL() : texture_id_(0) {
 }
 
 TextureGL::TextureGL(const gfx::Size& size) : texture_id_(0), size_(size) {
 }
 
 TextureGL::~TextureGL() {
   if (texture_id_) {
-    SharedResources* instance = SharedResources::GetInstance();
+    SharedResourcesGL* instance = SharedResourcesGL::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);
@@ skipping 27 matching lines @@
   } 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,
                      const gfx::Rect& clip_bounds_in_texture) {
-  SharedResources* instance = SharedResources::GetInstance();
+  SharedResourcesGL* instance = SharedResourcesGL::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_texture to size of texture.
@@ skipping 95 matching lines @@
 
   glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
 }
 
 CompositorGL::CompositorGL(CompositorDelegate* delegate,
                            gfx::AcceleratedWidget widget,
                            const gfx::Size& size)
     : Compositor(delegate, size),
       started_(false) {
   gl_surface_ = gfx::GLSurface::CreateViewGLSurface(false, widget);
-  gl_context_ = SharedResources::GetInstance()->
+  gl_context_ = SharedResourcesGL::GetInstance()->
       CreateContext(gl_surface_.get());
   gl_context_->MakeCurrent(gl_surface_.get());
   gl_context_->SetSwapInterval(1);
   glColorMask(true, true, true, true);
   glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
 }
 
 CompositorGL::~CompositorGL() {
   gl_context_ = NULL;
 }
@@ skipping 37 matching lines @@
 }
 
 void CompositorGL::Blur(const gfx::Rect& bounds) {
   NOTIMPLEMENTED();
 }
 
 // static
 Compositor* Compositor::Create(CompositorDelegate* owner,
                                gfx::AcceleratedWidget widget,
                                const gfx::Size& size) {
-  if (SharedResources::GetInstance() == NULL)
+  if (SharedResourcesGL::GetInstance() == NULL)
     return NULL;
   else
     return new CompositorGL(owner, widget, size);
 }
 
 }  // namespace ui