GLContext no longer holds a pointer to a GLSurface.

gpu/command_buffer/service/gles2_cmd_decoder.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 "gpu/command_buffer/service/gles2_cmd_decoder.h"
 
 #include <stdio.h>
 
 #include <algorithm>
 #include <list>
@@ skipping 20 matching lines @@
 #include "gpu/command_buffer/service/gl_utils.h"
 #include "gpu/command_buffer/service/gles2_cmd_validation.h"
 #include "gpu/command_buffer/service/program_manager.h"
 #include "gpu/command_buffer/service/renderbuffer_manager.h"
 #include "gpu/command_buffer/service/shader_manager.h"
 #include "gpu/command_buffer/service/shader_translator.h"
 #include "gpu/command_buffer/service/texture_manager.h"
 #include "gpu/GLES2/gles2_command_buffer.h"
 #include "ui/gfx/gl/gl_context.h"
 #include "ui/gfx/gl/gl_implementation.h"
+#include "ui/gfx/gl/gl_surface.h"
 
 #if !defined(GL_DEPTH24_STENCIL8)
 #define GL_DEPTH24_STENCIL8 0x88F0
 #endif
 
 namespace gpu {
 namespace gles2 {
 
 class GLES2DecoderImpl;
 
@@ skipping 613 matching lines @@
 
   // Overridden from AsyncAPIInterface.
   virtual Error DoCommand(unsigned int command,
                           unsigned int arg_count,
                           const void* args);
 
   // Overridden from AsyncAPIInterface.
   virtual const char* GetCommandName(unsigned int command_id) const;
 
   // Overridden from GLES2Decoder.
-  virtual bool Initialize(gfx::GLContext* context,
+  virtual bool Initialize(gfx::GLSurface* surface,
+                          gfx::GLContext* context,
                           const gfx::Size& size,
                           const DisallowedExtensions& disallowed_extensions,
                           const char* allowed_extensions,
                           const std::vector<int32>& attribs,
                           GLES2Decoder* parent,
                           uint32 parent_client_texture_id);
   virtual void Destroy();
   virtual void ResizeOffscreenFrameBuffer(const gfx::Size& size);
   virtual bool UpdateOffscreenFrameBufferSize();
   virtual bool MakeCurrent();
   virtual GLES2Util* GetGLES2Util() { return &util_; }
   virtual gfx::GLContext* GetGLContext() { return context_.get(); }
+  virtual gfx::GLSurface* GetGLSurface() { return surface_.get(); }
   virtual ContextGroup* GetContextGroup() { return group_.get(); }
 
   virtual void SetResizeCallback(Callback1<gfx::Size>::Type* callback);
   virtual void SetSwapBuffersCallback(Callback0::Type* callback);
   virtual void SetLatchCallback(const base::Callback<void(bool)>& callback);;
   virtual bool GetServiceTextureId(uint32 client_texture_id,
                                    uint32* service_texture_id);
 
   // Restores the current state to the user's settings.
   void RestoreCurrentFramebufferBindings();
@@ skipping 633 matching lines @@
   #define GLES2_CMD_OP(name) \
      Error Handle ## name(             \
        uint32 immediate_data_size,          \
        const gles2::name& args);            \
 
   GLES2_COMMAND_LIST(GLES2_CMD_OP)
 
   #undef GLES2_CMD_OP
 
   // The GL context this decoder renders to on behalf of the client.
+  scoped_ptr<gfx::GLSurface> surface_;
   scoped_ptr<gfx::GLContext> context_;
 
   // The ContextGroup for this decoder uses to track resources.
   ContextGroup::Ref group_;
 
   // A parent decoder can access this decoders saved offscreen frame buffer.
   // The parent pointer is reset if the parent is destroyed.
   base::WeakPtr<GLES2DecoderImpl> parent_;
 
   // Width and height to which an offscreen frame buffer should be resized on
@@ skipping 470 matching lines @@
   // empty string to CompileShader and this is not a valid shader.
   // TODO(apatrick): fix this test.
   if ((gfx::GetGLImplementation() == gfx::kGLImplementationEGLGLES2 &&
        !feature_info_->feature_flags().chromium_webglsl) ||
       gfx::GetGLImplementation() == gfx::kGLImplementationMockGL) {
     use_shader_translator_ = false;
   }
 }
 
 bool GLES2DecoderImpl::Initialize(
+    gfx::GLSurface* surface,
     gfx::GLContext* context,
     const gfx::Size& size,
     const DisallowedExtensions& disallowed_extensions,
     const char* allowed_extensions,
     const std::vector<int32>& attribs,
     GLES2Decoder* parent,
     uint32 parent_client_texture_id) {
   DCHECK(context);
   DCHECK(!context_.get());
 
+  // Take ownership of the GLSurface. TODO(apatrick): the decoder should not
+  // own the surface. It should be possible to freely switch the surface the
+  // context renders to.
+  surface_.reset(surface);
+
   // Take ownership of the GLContext.
   context_.reset(context);
 
   // Keep only a weak pointer to the parent so we don't unmap its client
   // frame buffer after it has been destroyed.
   if (parent)
     parent_ = static_cast<GLES2DecoderImpl*>(parent)->AsWeakPtr();
 
   if (!MakeCurrent()) {
     LOG(ERROR) << "GLES2DecoderImpl::Initialize failed because "
@@ skipping 38 matching lines @@
         texture_manager()->GetDefaultTextureInfo(GL_TEXTURE_CUBE_MAP);
     texture_units_[tt].bound_texture_cube_map = info;
     glBindTexture(GL_TEXTURE_CUBE_MAP, info->service_id());
     info = texture_manager()->GetDefaultTextureInfo(GL_TEXTURE_2D);
     texture_units_[tt].bound_texture_2d = info;
     glBindTexture(GL_TEXTURE_2D, info->service_id());
   }
   glActiveTexture(GL_TEXTURE0);
   CHECK_GL_ERROR();
 
-  if (context_->IsOffscreen()) {
+  if (surface_->IsOffscreen()) {
     ContextCreationAttribParser attrib_parser;
     if (!attrib_parser.Parse(attribs))
       return false;
 
     if (attrib_parser.samples_ > 0 && attrib_parser.sample_buffers_ > 0 &&
         (context_->HasExtension("GL_EXT_framebuffer_multisample") ||
          context_->HasExtension("GL_ANGLE_framebuffer_multisample"))) {
       // Per ext_framebuffer_multisample spec, need max bound on sample count.
       // max_sample_count must be initialized to a sane value.  If
       // glGetIntegerv() throws a GL error, it leaves its argument unchanged.
@@ skipping 287 matching lines @@
       GLuint service_id = info->service_id();
       glDeleteTextures(1, &service_id);
       RemoveTextureInfo(client_ids[ii]);
     }
   }
 }
 
 // }  // anonymous namespace
 
 bool GLES2DecoderImpl::MakeCurrent() {
-  return context_.get() ? context_->MakeCurrent() : false;
+  return context_.get() ? context_->MakeCurrent(surface_.get()) : false;
 }
 
 void GLES2DecoderImpl::RestoreCurrentRenderbufferBindings() {
   glBindRenderbufferEXT(
       GL_RENDERBUFFER,
       bound_renderbuffer_ ? bound_renderbuffer_->service_id() : 0);
 }
 
 static void RebindCurrentFramebuffer(
     GLenum target,
@@ skipping 50 matching lines @@
   if (bound_read_framebuffer_ != 0) {
     const FramebufferManager::FramebufferInfo::Attachment* attachment =
         bound_read_framebuffer_->GetAttachment(GL_COLOR_ATTACHMENT0);
     if (attachment) {
       return gfx::Size(attachment->width(), attachment->height());
     }
     return gfx::Size(0, 0);
   } else if (offscreen_target_frame_buffer_.get()) {
     return offscreen_size_;
   } else {
-    return context_->GetSize();
+    return surface_->GetSize();
   }
 }
 
 GLenum GLES2DecoderImpl::GetBoundReadFrameBufferInternalFormat() {
   if (bound_read_framebuffer_ != 0) {
     const FramebufferManager::FramebufferInfo::Attachment* attachment =
         bound_read_framebuffer_->GetAttachment(GL_COLOR_ATTACHMENT0);
     if (attachment) {
       return attachment->internal_format();
     }
@@ skipping 473 matching lines @@
       CreateFramebufferInfo(client_id, service_id);
       info = GetFramebufferInfo(client_id);
       IdAllocator* id_allocator =
           group_->GetIdAllocator(id_namespaces::kFramebuffers);
       id_allocator->MarkAsUsed(client_id);
     } else {
       service_id = info->service_id();
     }
     info->MarkAsValid();
   } else {
-    service_id = context_->GetBackingFrameBufferObject();
+    service_id = 0;
   }
 
   if (target == GL_FRAMEBUFFER || target == GL_DRAW_FRAMEBUFFER_EXT) {
     bound_draw_framebuffer_ = info;
   }
   if (target == GL_FRAMEBUFFER || target == GL_READ_FRAMEBUFFER_EXT) {
     bound_read_framebuffer_ = info;
   }
 
   // When rendering to an offscreen frame buffer, instead of unbinding from
@@ skipping 3595 matching lines @@
 
       // Run the callback with |binder| in scope, so that the callback can call
       // ReadPixels or CopyTexImage2D.
       if (swap_buffers_callback_.get()) {
         swap_buffers_callback_->Run();
       }
       return error::kNoError;
     }
   } else {
     TRACE_EVENT1("gpu", "GLContext::SwapBuffers", "frame", this_frame_number);
-    if (!context_->SwapBuffers()) {
+    if (!surface_->SwapBuffers()) {
       LOG(ERROR) << "Context lost because SwapBuffers failed.";
       return error::kLostContext;
     }
   }
 
   if (swap_buffers_callback_.get()) {
     swap_buffers_callback_->Run();
   }
 
   return error::kNoError;
@@ skipping 133 matching lines @@
   return error::kNoError;
 }
 
 // Include the auto-generated part of this file. We split this because it means
 // we can easily edit the non-auto generated parts right here in this file
 // instead of having to edit some template or the code generator.
 #include "gpu/command_buffer/service/gles2_cmd_decoder_autogen.h"
 
 }  // namespace gles2
 }  // namespace gpu