Use shared D3D9 texture to transport the compositor's backing buffer to the browser...

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 489 matching lines @@
                           const gfx::Size& size,
                           const DisallowedFeatures& disallowed_features,
                           const char* allowed_extensions,
                           const std::vector<int32>& attribs);
   virtual void Destroy();
   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 void SetResizeCallback(Callback1<gfx::Size>::Type* callback);
 
-#if defined(OS_MACOSX)
   virtual void SetSwapBuffersCallback(Callback0::Type* callback);
-#endif
 
   virtual void SetStreamTextureManager(StreamTextureManager* manager);
   virtual bool GetServiceTextureId(uint32 client_texture_id,
                                    uint32* service_texture_id);
 
   // Restores the current state to the user's settings.
   void RestoreCurrentFramebufferBindings();
   void RestoreCurrentRenderbufferBindings();
   void RestoreCurrentTexture2DBindings();
 
@@ skipping 787 matching lines @@
   scoped_ptr<FrameBuffer> offscreen_saved_frame_buffer_;
   scoped_ptr<Texture> offscreen_saved_color_texture_;
 
   // The copy that is used as the destination for multi-sample resolves.
   scoped_ptr<FrameBuffer> offscreen_resolved_frame_buffer_;
   scoped_ptr<Texture> offscreen_resolved_color_texture_;
   GLenum offscreen_saved_color_format_;
 
   scoped_ptr<Callback1<gfx::Size>::Type> resize_callback_;
 
-#if defined(OS_MACOSX)
   scoped_ptr<Callback0::Type> swap_buffers_callback_;
-#endif
 
   StreamTextureManager* stream_texture_manager_;
 
   // The format of the back buffer_
   GLenum back_buffer_color_format_;
   bool back_buffer_has_depth_;
   bool back_buffer_has_stencil_;
 
   bool teximage2d_faster_than_texsubimage2d_;
   bool bufferdata_faster_than_buffersubdata_;
@@ skipping 876 matching lines @@
 bool GLES2DecoderImpl::MakeCurrent() {
   bool result = context_.get() ? context_->MakeCurrent(surface_.get()) : false;
   if (result && WasContextLost()) {
     LOG(ERROR) << "  GLES2DecoderImpl: Context lost during MakeCurrent.";
     result = false;
   }
 
   return result;
 }
 
+void GLES2DecoderImpl::ReleaseCurrent() {
+  if (context_.get())
+    context_->ReleaseCurrent(surface_.get());
+}
+
 void GLES2DecoderImpl::RestoreCurrentRenderbufferBindings() {
   glBindRenderbufferEXT(
       GL_RENDERBUFFER,
       bound_renderbuffer_ ? bound_renderbuffer_->service_id() : 0);
 }
 
 static void RebindCurrentFramebuffer(
     GLenum target,
     FramebufferManager::FramebufferInfo* info,
     FrameBuffer* offscreen_frame_buffer) {
@@ skipping 128 matching lines @@
         GL_TEXTURE_WRAP_T,
         GL_CLAMP_TO_EDGE);
   }
 }
 
 void GLES2DecoderImpl::SetResizeCallback(
     Callback1<gfx::Size>::Type* callback) {
   resize_callback_.reset(callback);
 }
 
-#if defined(OS_MACOSX)
 void GLES2DecoderImpl::SetSwapBuffersCallback(Callback0::Type* callback) {
   swap_buffers_callback_.reset(callback);
 }
-#endif
 
 void GLES2DecoderImpl::SetStreamTextureManager(StreamTextureManager* manager) {
   stream_texture_manager_ = manager;
 }
 
 bool GLES2DecoderImpl::GetServiceTextureId(uint32 client_texture_id,
                                            uint32* service_texture_id) {
   TextureManager::TextureInfo* texture =
       texture_manager()->GetTextureInfo(client_texture_id);
   if (texture) {
@@ skipping 4455 matching lines @@
 
       UpdateParentTextureInfo();
     }
 
     ScopedGLErrorSuppressor suppressor(this);
 
     if (IsOffscreenBufferMultisampled()) {
       // For multisampled buffers, bind the resolved frame buffer so that
       // callbacks can call ReadPixels or CopyTexImage2D.
       ScopedResolvedFrameBufferBinder binder(this, true, false);
-#if defined(OS_MACOSX)
       if (swap_buffers_callback_.get()) {
         swap_buffers_callback_->Run();
       }
-#endif
+
       return error::kNoError;
     } else {
       ScopedFrameBufferBinder binder(this,
                                      offscreen_target_frame_buffer_->id());
 
       if (surface_->IsOffscreen()) {
         // Copy the target frame buffer to the saved offscreen texture.
         offscreen_saved_color_texture_->Copy(
             offscreen_saved_color_texture_->size(),
             offscreen_saved_color_format_);
 
         // Ensure the side effects of the copy are visible to the parent
         // context. There is no need to do this for ANGLE because it uses a
         // single D3D device for all contexts.
         if (!IsAngle())
           glFlush();
       }
 
       // Run the callback with |binder| in scope, so that the callback can call
       // ReadPixels or CopyTexImage2D.
-#if defined(OS_MACOSX)
       if (swap_buffers_callback_.get()) {
         swap_buffers_callback_->Run();
       }
-#endif
+
       return error::kNoError;
     }
   } else {
     TRACE_EVENT1("gpu", "GLContext::SwapBuffers", "frame", this_frame_number);
     if (!surface_->SwapBuffers()) {
       LOG(ERROR) << "Context lost because SwapBuffers failed.";
       return error::kLostContext;
     }
   }
 
-#if defined(OS_MACOSX)
   if (swap_buffers_callback_.get()) {
     swap_buffers_callback_->Run();
   }
-#endif
 
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleEnableFeatureCHROMIUM(
     uint32 immediate_data_size, const gles2::EnableFeatureCHROMIUM& c) {
   Bucket* bucket = GetBucket(c.bucket_id);
   if (!bucket || bucket->size() == 0) {
     return error::kInvalidArguments;
   }
@@ skipping 293 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