Revert 205481 "Virtual context MakeCurrent tweaks."

trunk/src/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,
-      public GpuCommandBufferStub::DestructionObserver {
+class IOSurfaceImageTransportSurface : public gfx::NoOpGLSurfaceCGL,
+                                       public ImageTransportSurface {
  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 56 matching lines @@
       io_surface_handle_(0),
       context_(NULL),
       scale_factor_(1.f),
       made_current_(false),
       is_swap_buffers_pending_(false),
       did_unschedule_(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;
 
   if (!helper_->Initialize())
     return false;
-
-  if (!NoOpGLSurfaceCGL::Initialize()) {
-    helper_->Destroy();
-    return false;
-  }
-
-  helper_->stub()->AddDestructionObserver(this);
-  return true;
+  return NoOpGLSurfaceCGL::Initialize();
 }
 
 void IOSurfaceImageTransportSurface::Destroy() {
   UnrefIOSurface();
 
   helper_->Destroy();
   NoOpGLSurfaceCGL::Destroy();
 }
 
 bool IOSurfaceImageTransportSurface::DeferDraws() {
@@ skipping 141 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_) {
@@ skipping 158 matching lines @@
           manager, stub, surface.get(), false));
   }
 }
 
 // static
 void ImageTransportSurface::SetAllowOSMesaForTesting(bool allow) {
   g_allow_os_mesa = allow;
 }
 
 }  // namespace content