Delete background tab IOSurfaces on Mac.

content/browser/gpu/gpu_process_host.h

 // 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.
 
 #ifndef CONTENT_BROWSER_GPU_GPU_PROCESS_HOST_H_
 #define CONTENT_BROWSER_GPU_GPU_PROCESS_HOST_H_
 #pragma once
 
 #include <map>
 #include <queue>
@@ skipping 11 matching lines @@
 #include "ipc/ipc_message.h"
 #include "ui/gfx/native_widget_types.h"
 
 class GpuMainThread;
 struct GPUCreateCommandBufferConfig;
 struct GpuHostMsg_AcceleratedSurfaceBuffersSwapped_Params;
 struct GpuHostMsg_AcceleratedSurfacePostSubBuffer_Params;
 struct GpuHostMsg_AcceleratedSurfaceRelease_Params;
 
 class BrowserChildProcessHostImpl;
+class RenderWidgetHelper;
 
 class GpuProcessHost : public content::BrowserChildProcessHostDelegate,
                        public IPC::Message::Sender,
                        public base::NonThreadSafe {
  public:
   enum GpuProcessKind {
     GPU_PROCESS_KIND_UNSANDBOXED,
     GPU_PROCESS_KIND_SANDBOXED,
     GPU_PROCESS_KIND_COUNT
   };
@@ skipping 46 matching lines @@
       const CreateCommandBufferCallback& callback);
 
   // Whether this GPU process is set up to use software rendering.
   bool software_rendering();
 
   // What kind of GPU process, e.g. sandboxed or unsandboxed.
   GpuProcessKind kind();
 
   void ForceShutdown();
 
+  void RegisterRenderWidgetHelper(
+      int render_process_id,
+      const scoped_refptr<RenderWidgetHelper>& render_widget_helper);
+
+  void UnregisterRenderWidgetHelper(int render_process_id);
+
  private:
   static bool HostIsValid(GpuProcessHost* host);
 
   GpuProcessHost(int host_id, GpuProcessKind kind);
   virtual ~GpuProcessHost();
 
   bool Init();
 
   // Post an IPC message to the UI shim's message handler on the UI thread.
   void RouteOnUIThread(const IPC::Message& message);
 
   // BrowserChildProcessHostDelegate implementation.
   virtual bool OnMessageReceived(const IPC::Message& message) OVERRIDE;
   virtual void OnChannelConnected(int32 peer_pid) OVERRIDE;
   virtual void OnProcessLaunched() OVERRIDE;
   virtual void OnProcessCrashed(int exit_code) OVERRIDE;
 
   // Message handlers.
   void OnChannelEstablished(const IPC::ChannelHandle& channel_handle);
   void OnCommandBufferCreated(const int32 route_id);
   void OnDestroyCommandBuffer(int32 surface_id);
 
+#if defined(OS_MACOSX)
+  void OnAcceleratedSurfaceBuffersSwapped(
+      const GpuHostMsg_AcceleratedSurfaceBuffersSwapped_Params& params);
+#endif
 #if defined(OS_WIN) && !defined(USE_AURA)
   void OnAcceleratedSurfaceBuffersSwapped(
       const GpuHostMsg_AcceleratedSurfaceBuffersSwapped_Params& params);
   void OnAcceleratedSurfacePostSubBuffer(
       const GpuHostMsg_AcceleratedSurfacePostSubBuffer_Params& params);
   void OnAcceleratedSurfaceSuspend(int32 surface_id);
   void OnAcceleratedSurfaceRelease(
     const GpuHostMsg_AcceleratedSurfaceRelease_Params& params);
 #endif
 
@@ skipping 51 matching lines @@
 
   // Master switch for enabling/disabling GPU acceleration for the current
   // browser session. It does not change the acceleration settings for
   // existing tabs, just the future ones.
   static bool gpu_enabled_;
 
   static bool hardware_gpu_enabled_;
 
   scoped_ptr<BrowserChildProcessHostImpl> process_;
 
+  std::map<int, scoped_refptr<RenderWidgetHelper> > render_widget_helpers_;

[piman, 2012/04/18 21:07:44]

Is this map really necessary? There's already a renderer_process_id ->
RenderProcessHost map  (through RenderProcessHost::FromID) and
RenderProcessHostImpl owns the widget_helper_

I'm also concerned about that a GpuProcessHost might outlive a
RenderWidgetHelper and still receive straggler messages for it, but that
RenderWidgetHelper wouldn't have unregistered from this GpuProcessHost because
it had to talk to a new GPU process.

[jbates, 2012/04/18 23:01:58]

Sadly RenderProcessHost::FromID is UI thread only with a DCHECK to enforce.
I'm not sure I'm following this scenario. The refptr prevents the GpuProcessHost
from outliving the RenderWidgetHelper. When is there a new GPU process while the
old GpuProcessHost remains?

[piman, 2012/04/18 23:32:22]

You can have >1 GpuProcessHost because the teardown of a GPU process is
asynchronous. See GpuMessageFilter::OnEstablishGpuChannel and in particular
GpuProcessHost::FromID for cases were we return NULL (therefore creating a new
one) while there are still some that are live.

I missed the scoped_refptr but I wonder if it may extend the lifetime of the
RenderWidgetHelper beyond what's expected (it has some raw back pointers). Maybe
you've already thought about these issues and it's all fine?

[jbates, 2012/04/19 01:24:18]

Hmm, a scoped_refptr with an externally owned raw pointer member == guaranteed
fun! I'll track down the usage of resource_dispatcher_host_ to see if there are
any problems.

+
   DISALLOW_COPY_AND_ASSIGN(GpuProcessHost);
 };
 
 #endif  // CONTENT_BROWSER_GPU_GPU_PROCESS_HOST_H_