Allow GLES2CmdDecoder to change the GLSurface associated with the default FBO.

gpu/command_buffer/service/gles2_cmd_decoder.cc

 // 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.
 
 #include "gpu/command_buffer/service/gles2_cmd_decoder.h"
 
 #include <stdio.h>
 
 #include <algorithm>
 #include <list>
@@ skipping 464 matching lines @@
   virtual const char* GetCommandName(unsigned int command_id) const;
 
   // Overridden from GLES2Decoder.
   virtual bool Initialize(const scoped_refptr<gfx::GLSurface>& surface,
                           const scoped_refptr<gfx::GLContext>& context,
                           bool offscreen,
                           const gfx::Size& size,
                           const DisallowedFeatures& disallowed_features,
                           const char* allowed_extensions,
                           const std::vector<int32>& attribs);
-  virtual void Destroy();
+  virtual void Destroy(bool have_context);
+  virtual void SetSurface(
+      const scoped_refptr<gfx::GLSurface>& surface) OVERRIDE;
   virtual bool SetParent(GLES2Decoder* parent_decoder,
                          uint32 parent_texture_id);
   virtual bool ResizeOffscreenFrameBuffer(const gfx::Size& size);
   void UpdateParentTextureInfo();
   virtual bool MakeCurrent();
   virtual void ReleaseCurrent();
   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 QueryManager* GetQueryManager() { return query_manager_.get(); }
   virtual bool ProcessPendingQueries();
 
   virtual void SetGLError(GLenum error, const char* msg);
   virtual void SetResizeCallback(
       const base::Callback<void(gfx::Size)>& callback);
 
   virtual void SetMsgCallback(const MsgCallback& callback);
 
@@ skipping 1472 matching lines @@
 }
 
 bool GLES2DecoderImpl::Initialize(
     const scoped_refptr<gfx::GLSurface>& surface,
     const scoped_refptr<gfx::GLContext>& context,
     bool offscreen,
     const gfx::Size& size,
     const DisallowedFeatures& disallowed_features,
     const char* allowed_extensions,
     const std::vector<int32>& attribs) {
-  DCHECK(context);
+  DCHECK(context->IsCurrent(surface.get()));
   DCHECK(!context_.get());
 
   if (CommandLine::ForCurrentProcess()->HasSwitch(
       switches::kEnableGPUDebugging)) {
     set_debug(true);
   }
 
   if (CommandLine::ForCurrentProcess()->HasSwitch(
       switches::kEnableGPUCommandLogging)) {
     set_log_commands(true);
   }
 
   compile_shader_always_succeeds_ = CommandLine::ForCurrentProcess()->HasSwitch(
       switches::kCompileShaderAlwaysSucceeds);
 
-  // Take ownership of the GLSurface. TODO(apatrick): once the parent / child
-  // context is retired, the decoder should not take an initial surface as
-  // an argument to this function.
-  // Maybe create a short lived offscreen GLSurface for the purpose of
-  // initializing the decoder's GLContext.
+
+  // Take ownership of the context and surface. The surface can be replaced with
+  // SetSurface.
+  context_ = context;
   surface_ = surface;
 
-  // Take ownership of the GLContext.
-  context_ = context;
-
-  if (!MakeCurrent()) {
-    LOG(ERROR) << "GLES2DecoderImpl::Initialize failed because "
-               << "MakeCurrent failed.";
-    group_ = NULL;  // Must not destroy ContextGroup if it is not initialized.
-    Destroy();
-    return false;
-  }
-
   if (!group_->Initialize(disallowed_features, allowed_extensions)) {
     LOG(ERROR) << "GpuScheduler::InitializeCommon failed because group "
                << "failed to initialize.";
     group_ = NULL;  // Must not destroy ContextGroup if it is not initialized.
-    Destroy();
+    Destroy(true);
     return false;
   }
   CHECK_GL_ERROR();
 
   copy_texture_CHROMIUM_.reset(new CopyTextureCHROMIUMResourceManager());
   copy_texture_CHROMIUM_->Initialize();
   CHECK_GL_ERROR();
 
   disallowed_features_ = disallowed_features;
 
@@ skipping 166 matching lines @@
     offscreen_saved_frame_buffer_.reset(new FrameBuffer(this));
     offscreen_saved_frame_buffer_->Create();
     //
     offscreen_saved_color_texture_.reset(new Texture(this));
     offscreen_saved_color_texture_->Create();
 
     // Allocate the render buffers at their initial size and check the status
     // of the frame buffers is okay.
     if (!ResizeOffscreenFrameBuffer(size)) {
       LOG(ERROR) << "Could not allocate offscreen buffer storage.";
-      Destroy();
+      Destroy(true);
       return false;
     }
 
     // Bind to the new default frame buffer (the offscreen target frame buffer).
     // This should now be associated with ID zero.
     DoBindFramebuffer(GL_FRAMEBUFFER, 0);
   }
 
   // Clear the backbuffer.
   glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
@@ skipping 85 matching lines @@
       gfx::GetGLImplementation() == gfx::kGLImplementationEGLGLES2 ?
           ShaderTranslatorInterface::kGlslES : ShaderTranslatorInterface::kGlsl;
   ShaderTranslatorInterface::GlslBuiltInFunctionBehavior function_behavior =
       needs_glsl_built_in_function_emulation_ ?
           ShaderTranslatorInterface::kGlslBuiltInFunctionEmulated :
           ShaderTranslatorInterface::kGlslBuiltInFunctionOriginal;
   if (!vertex_translator_->Init(
           SH_VERTEX_SHADER, shader_spec, &resources,
           implementation_type, function_behavior)) {
     LOG(ERROR) << "Could not initialize vertex shader translator.";
-    Destroy();
+    Destroy(true);
     return false;
   }
   fragment_translator_.reset(new ShaderTranslator);
   if (!fragment_translator_->Init(
           SH_FRAGMENT_SHADER, shader_spec, &resources,
           implementation_type, function_behavior)) {
     LOG(ERROR) << "Could not initialize fragment shader translator.";
-    Destroy();
+    Destroy(true);
     return false;
   }
   return true;
 }
 
 bool GLES2DecoderImpl::GenBuffersHelper(GLsizei n, const GLuint* client_ids) {
   for (GLsizei ii = 0; ii < n; ++ii) {
     if (GetBufferInfo(client_ids[ii])) {
       return false;
     }
@@ skipping 164 matching lines @@
       }
 #endif
       RemoveTextureInfo(client_ids[ii]);
     }
   }
 }
 
 // }  // anonymous namespace
 
 bool GLES2DecoderImpl::MakeCurrent() {
-  bool result = context_.get() ? context_->MakeCurrent(surface_.get()) : false;
-  if (result && WasContextLost()) {
+  if (!context_.get() || !context_->MakeCurrent(surface_.get()))
+    return false;
+
+  if (WasContextLost()) {
     LOG(ERROR) << "  GLES2DecoderImpl: Context lost during MakeCurrent.";
-    result = false;
+    return false;
   }
 
-  return result;
+  return true;
 }
 
 void GLES2DecoderImpl::ReleaseCurrent() {
   if (context_.get())
     context_->ReleaseCurrent(surface_.get());
 }
 
 void GLES2DecoderImpl::RestoreCurrentRenderbufferBindings() {
   RenderbufferManager::RenderbufferInfo* renderbuffer =
       GetRenderbufferInfoForTarget(GL_RENDERBUFFER);
@@ skipping 206 matching lines @@
                                            uint32* service_texture_id) {
   TextureManager::TextureInfo* texture =
       texture_manager()->GetTextureInfo(client_texture_id);
   if (texture) {
     *service_texture_id = texture->service_id();
     return true;
   }
   return false;
 }
 
-void GLES2DecoderImpl::Destroy() {
-  bool have_context = context_.get() && MakeCurrent();
+void GLES2DecoderImpl::Destroy(bool have_context) {
+  DCHECK(!have_context || context_->IsCurrent(NULL));
 
   ChildList children = children_;
   for (ChildList::iterator it = children.begin(); it != children.end(); ++it)
     (*it)->SetParent(NULL, 0);
   DCHECK(children_.empty());
   SetParent(NULL, 0);
 
   // Unbind everything.
   vertex_attrib_manager_.reset();
   texture_units_.reset();
@@ skipping 87 matching lines @@
 
 #if defined(OS_MACOSX)
   for (TextureToIOSurfaceMap::iterator it = texture_to_io_surface_map_.begin();
        it != texture_to_io_surface_map_.end(); ++it) {
     CFRelease(it->second);
   }
   texture_to_io_surface_map_.clear();
 #endif
 }
 
+void GLES2DecoderImpl::SetSurface(
+    const scoped_refptr<gfx::GLSurface>& surface) {
+  DCHECK(context_->IsCurrent(NULL));
+  DCHECK(surface_.get());
+  surface_ = surface;
+  RestoreCurrentFramebufferBindings();
+}
+
 bool GLES2DecoderImpl::SetParent(GLES2Decoder* new_parent,
                                  uint32 new_parent_texture_id) {
   if (!offscreen_saved_color_texture_.get())
     return false;
 
   // Remove the saved frame buffer mapping from the parent decoder. The
   // parent pointer is a weak pointer so it will be null if the parent has
   // already been destroyed.
   if (parent_) {
     ChildList::iterator it = std::find(
@@ skipping 5865 matching lines @@
   BindAndApplyTextureParameters(info);
 }
 
 // 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