Refactor how surfaces are acquired for GPU compositing.

chrome/browser/gpu_process_host_ui_shim.h

 // Copyright (c) 2010 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
 // portion of this class, the GpuProcessHost, is responsible for
 // shuttling messages between the browser and GPU processes.
 
+#include <map>
 #include <queue>
 
 #include "base/callback.h"
 #include "base/linked_ptr.h"
+#include "base/ref_counted.h"
 #include "base/scoped_ptr.h"
 #include "base/singleton.h"
 #include "base/values.h"
 #include "base/threading/non_thread_safe.h"
 #include "chrome/common/gpu_feature_flags.h"
 #include "chrome/common/gpu_info.h"
 #include "chrome/common/message_router.h"
 #include "ipc/ipc_channel.h"
 #include "ui/gfx/native_widget_types.h"
 
 namespace gfx {
 class Size;
 }
 
 class GpuBlacklist;
 struct GPUCreateCommandBufferConfig;
 class GPUInfo;
 struct GpuHostMsg_AcceleratedSurfaceSetIOSurface_Params;
 struct GpuHostMsg_AcceleratedSurfaceBuffersSwapped_Params;
 
 namespace IPC {
 struct ChannelHandle;
 class Message;
 }
 
+class RenderWidgetHostView;
+
 class GpuProcessHostUIShim : public IPC::Channel::Sender,
                              public IPC::Channel::Listener,
                              public base::NonThreadSafe {
  public:
   // Getter for the singleton. This will return NULL on failure.
   static GpuProcessHostUIShim* GetInstance();
 
   int32 GetNextRoutingId();
 
   // IPC::Channel::Sender implementation.
@@ skipping 113 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_;
 
+  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.
+  class ViewSurface : public base::RefCounted<ViewSurface> {
+   public:
+    explicit ViewSurface(ViewID view_id);
+    ~ViewSurface();
+    gfx::PluginWindowHandle surface() { return surface_; }
+   private:
+    RenderWidgetHostView* GetRenderWidgetHostView();
+    ViewID view_id_;
+    gfx::PluginWindowHandle surface_;
+  };
+
+  std::map<ViewID, scoped_refptr<ViewSurface> > acquired_surfaces_;
+
   bool initialized_;
   bool initialized_successfully_;
 
   bool gpu_feature_flags_set_;
   scoped_ptr<GpuBlacklist> gpu_blacklist_;
   GpuFeatureFlags gpu_feature_flags_;
 };
 
 #endif  // CHROME_BROWSER_GPU_PROCESS_HOST_UI_SHIM_H_