Progress towards fixing 77536

chrome/browser/gpu_process_host_ui_shim.h

 // 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.
 
 #ifndef CHROME_BROWSER_GPU_PROCESS_HOST_UI_SHIM_H_
 #define CHROME_BROWSER_GPU_PROCESS_HOST_UI_SHIM_H_
 #pragma once
 
 // This class lives on the UI thread and supports classes like the
 // BackingStoreProxy, which must live on the UI thread. The IO thread
@@ skipping 104 matching lines @@
 
   // Sends a reply message later when the next GpuHostMsg_SynchronizeReply comes
   // in.
   void Synchronize(SynchronizeCallback* callback);
 
   typedef Callback1<int32>::Type CreateCommandBufferCallback;
 
   // Tells the GPU process to create a new command buffer that draws into the
   // window associated with the given renderer.
   void CreateViewCommandBuffer(
+      gfx::PluginWindowHandle compositing_surface,
       int32 render_view_id,
       int32 renderer_id,
       const GPUCreateCommandBufferConfig& init_params,
       CreateCommandBufferCallback* callback);
 
 #if defined(OS_MACOSX)
   // Notify the GPU process that an accelerated surface was destroyed.
   void DidDestroyAcceleratedSurface(int renderer_id, int32 render_view_id);
 
   // TODO(apatrick): Remove this when mac does not use AcceleratedSurfaces for
@@ skipping 55 matching lines @@
   // the GPU process, but haven't heard back about yet.
   std::queue<linked_ptr<EstablishChannelCallback> > channel_requests_;
 
   // The pending synchronization requests we need to reply to.
   std::queue<linked_ptr<SynchronizeCallback> > synchronize_requests_;
 
   // The pending create command buffer requests we need to reply to.
   std::queue<linked_ptr<CreateCommandBufferCallback> >
       create_command_buffer_requests_;
 
+#if defined(OS_LINUX)
   typedef std::pair<int32 /* renderer_id */,
                     int32 /* render_view_id */> ViewID;
 
-  // Encapsulates surfaces that we acquire when creating view command buffers.
-  // We assume that a render view has at most 1 such surface associated
-  // with it.  Multimap is used to simulate reference counting, see comment in
+  // Encapsulates surfaces that we lock when creating view command buffers.
+  // We release this lock once the command buffer (or associated GPU process)
+  // is destroyed. This prevents the browser from destroying the surface
+  // while the GPU process is drawing to it.
+
+  // Multimap is used to simulate reference counting, see comment in
   // GpuProcessHostUIShim::CreateViewCommandBuffer.
-  class ViewSurface;
-  typedef std::multimap<ViewID, linked_ptr<ViewSurface> > ViewSurfaceMap;
-  ViewSurfaceMap acquired_surfaces_;
+  class SurfaceRef;
+  typedef std::multimap<ViewID, linked_ptr<SurfaceRef> > SurfaceRefMap;
+  SurfaceRefMap surface_refs_;
+#endif
 
   // In single process and in process GPU mode, this references the
   // GpuChannelManager or null otherwise. It must be called and deleted on the
   // GPU thread.
   GpuChannelManager* gpu_channel_manager_;
 
   // This is likewise single process / in process GPU specific. This is a Sender
   // implementation that forwards IPC messages to this UI shim on the UI thread.
   IPC::Channel::Sender* ui_thread_sender_;
 };
 
 #endif  // CHROME_BROWSER_GPU_PROCESS_HOST_UI_SHIM_H_