Virtual context MakeCurrent tweaks.

content/common/gpu/image_transport_surface_mac.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 "content/common/gpu/image_transport_surface.h"
 
 #include "base/mac/scoped_cftyperef.h"
 #include "base/memory/scoped_ptr.h"
+#include "content/common/gpu/gpu_command_buffer_stub.h"
 #include "content/common/gpu/gpu_messages.h"
 #include "ui/gfx/native_widget_types.h"
 #include "ui/gl/gl_bindings.h"
 #include "ui/gl/gl_context.h"
 #include "ui/gl/gl_implementation.h"
 #include "ui/gl/gl_surface_cgl.h"
 #include "ui/gl/gl_surface_osmesa.h"
 #include "ui/surface/io_surface_support_mac.h"
 
 namespace content {
 namespace {
 
 // IOSurface dimensions will be rounded up to a multiple of this value in order
 // to reduce memory thrashing during resize. This must be a power of 2.
 const uint32 kIOSurfaceDimensionRoundup = 64;
 
 int RoundUpSurfaceDimension(int number) {
   DCHECK(number >= 0);
   // Cast into unsigned space for portable bitwise ops.
   uint32 unsigned_number = static_cast<uint32>(number);
   uint32 roundup_sub_1 = kIOSurfaceDimensionRoundup - 1;
   unsigned_number = (unsigned_number + roundup_sub_1) & ~roundup_sub_1;
   return static_cast<int>(unsigned_number);
 }
 
 // We are backed by an offscreen surface for the purposes of creating
 // a context, but use FBOs to render to texture backed IOSurface
-class IOSurfaceImageTransportSurface : public gfx::NoOpGLSurfaceCGL,
-                                       public ImageTransportSurface {
+class IOSurfaceImageTransportSurface
+    : public gfx::NoOpGLSurfaceCGL,
+      public ImageTransportSurface,
+      public GpuCommandBufferStub::DestructionObserver {
  public:
   IOSurfaceImageTransportSurface(GpuChannelManager* manager,
                                  GpuCommandBufferStub* stub,
                                  gfx::PluginWindowHandle handle);
 
   // GLSurface implementation
   virtual bool Initialize() OVERRIDE;
   virtual void Destroy() OVERRIDE;
   virtual bool DeferDraws() OVERRIDE;
   virtual bool IsOffscreen() OVERRIDE;
   virtual bool SwapBuffers() OVERRIDE;
   virtual bool PostSubBuffer(int x, int y, int width, int height) OVERRIDE;
   virtual std::string GetExtensions() OVERRIDE;
   virtual gfx::Size GetSize() OVERRIDE;
   virtual bool OnMakeCurrent(gfx::GLContext* context) OVERRIDE;
   virtual unsigned int GetBackingFrameBufferObject() OVERRIDE;
   virtual bool SetBackbufferAllocation(bool allocated) OVERRIDE;
   virtual void SetFrontbufferAllocation(bool allocated) OVERRIDE;
 
  protected:
   // ImageTransportSurface implementation
   virtual void OnBufferPresented(
       const AcceleratedSurfaceMsg_BufferPresented_Params& params) OVERRIDE;
   virtual void OnResizeViewACK() OVERRIDE;
   virtual void OnResize(gfx::Size size, float scale_factor) OVERRIDE;
   virtual void SetLatencyInfo(const ui::LatencyInfo&) OVERRIDE;
 
+  // GpuCommandBufferStub::DestructionObserver implementation.
+  virtual void OnWillDestroyStub() OVERRIDE;
+
  private:
   virtual ~IOSurfaceImageTransportSurface() OVERRIDE;
 
   void AdjustBufferAllocation();
   void UnrefIOSurface();
   void CreateIOSurface();
 
   // Tracks the current buffer allocation state.
   bool backbuffer_suggested_allocation_;
   bool frontbuffer_suggested_allocation_;
@@ skipping 19 matching lines @@
   // Whether a SwapBuffers is pending.
   bool is_swap_buffers_pending_;
 
   // Whether we unscheduled command buffer because of pending SwapBuffers.
   bool did_unschedule_;
 
   ui::LatencyInfo latency_info_;
 
   scoped_ptr<ImageTransportHelper> helper_;
 
+  bool added_observer_;
+
   DISALLOW_COPY_AND_ASSIGN(IOSurfaceImageTransportSurface);
 };
 
 void AddBooleanValue(CFMutableDictionaryRef dictionary,
                      const CFStringRef key,
                      bool value) {
   CFDictionaryAddValue(dictionary, key,
                        (value ? kCFBooleanTrue : kCFBooleanFalse));
 }
 
@@ skipping 12 matching lines @@
     : gfx::NoOpGLSurfaceCGL(gfx::Size(1, 1)),
       backbuffer_suggested_allocation_(true),
       frontbuffer_suggested_allocation_(true),
       fbo_id_(0),
       texture_id_(0),
       io_surface_handle_(0),
       context_(NULL),
       scale_factor_(1.f),
       made_current_(false),
       is_swap_buffers_pending_(false),
-      did_unschedule_(false) {
+      did_unschedule_(false),
+      added_observer_(false) {
   helper_.reset(new ImageTransportHelper(this, manager, stub, handle));
 }
 
 IOSurfaceImageTransportSurface::~IOSurfaceImageTransportSurface() {
-  Destroy();
 }
 
 bool IOSurfaceImageTransportSurface::Initialize() {
   // Only support IOSurfaces if the GL implementation is the native desktop GL.
   // IO surfaces will not work with, for example, OSMesa software renderer
   // GL contexts.
   if (gfx::GetGLImplementation() != gfx::kGLImplementationDesktopGL &&
       gfx::GetGLImplementation() != gfx::kGLImplementationAppleGL)
     return false;
 
@@ skipping 154 matching lines @@
   scale_factor_ = scale_factor;
 
   CreateIOSurface();
 }
 
 void IOSurfaceImageTransportSurface::SetLatencyInfo(
     const ui::LatencyInfo& latency_info) {
   latency_info_ = latency_info;
 }
 
+void IOSurfaceImageTransportSurface::OnWillDestroyStub() {
+  helper_->stub()->RemoveDestructionObserver(this);
+  Destroy();
+}
+
 void IOSurfaceImageTransportSurface::UnrefIOSurface() {
   // If we have resources to destroy, then make sure that we have a current
   // context which we can use to delete the resources.
   if (context_ || fbo_id_ || texture_id_) {
     DCHECK(gfx::GLContext::GetCurrent() == context_);
     DCHECK(context_->IsCurrent(this));
     DCHECK(CGLGetCurrentContext());
   }
 
   if (fbo_id_) {
     glDeleteFramebuffersEXT(1, &fbo_id_);
     fbo_id_ = 0;
   }
 
   if (texture_id_) {
     glDeleteTextures(1, &texture_id_);
     texture_id_ = 0;
   }
 
   io_surface_.reset();
   io_surface_handle_ = 0;
 }
 
 void IOSurfaceImageTransportSurface::CreateIOSurface() {
   gfx::Size new_rounded_size(RoundUpSurfaceDimension(size_.width()),
                              RoundUpSurfaceDimension(size_.height()));
 
+  if (!added_observer_) {
+    helper_->stub()->AddDestructionObserver(this);

[piman, 2013/06/05 00:05:33]

Why not do that always in Initialize?
Destroy seems to be doing more than just destroying the surface, and also that
would remove the need for the extra bool.

[no sievers, 2013/06/05 00:19:05]

Done.

I think I was under the false impression that you cannot get to the stub yet
during Init(). But looking at the code that does not seem to be a problem at
all.

+    added_observer_ = true;
+  }
+
   // Only recreate surface when the rounded up size has changed.
   if (io_surface_.get() && new_rounded_size == rounded_size_)
     return;
 
   // This trace event is used in gpu_feature_browsertest.cc - the test will need
   // to be updated if this event is changed or moved.
   TRACE_EVENT2("gpu", "IOSurfaceImageTransportSurface::CreateIOSurface",
                "width", new_rounded_size.width(),
                "height", new_rounded_size.height());
 
@@ skipping 131 matching lines @@
           manager, stub, surface.get(), false));
   }
 }
 
 // static
 void ImageTransportSurface::SetAllowOSMesaForTesting(bool allow) {
   g_allow_os_mesa = allow;
 }
 
 }  // namespace content