aura: Allow delegated frames to be used by more than one impl layer.

content/browser/renderer_host/render_widget_host_view_aura.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_RENDERER_HOST_RENDER_WIDGET_HOST_VIEW_AURA_H_
 #define CONTENT_BROWSER_RENDERER_HOST_RENDER_WIDGET_HOST_VIEW_AURA_H_
 
 #include <map>
 #include <string>
 #include <vector>
 
 #include "base/callback.h"
 #include "base/gtest_prod_util.h"
 #include "base/memory/linked_ptr.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
+#include "cc/layers/delegated_frame_provider.h"
+#include "cc/layers/delegated_frame_resource_collection.h"
 #include "cc/resources/texture_mailbox.h"
 #include "content/browser/accessibility/browser_accessibility_manager.h"
 #include "content/browser/aura/image_transport_factory.h"
 #include "content/browser/renderer_host/frame_memory_manager.h"
 #include "content/browser/renderer_host/render_widget_host_view_base.h"
 #include "content/common/content_export.h"
 #include "content/common/gpu/client/gl_helper.h"
 #include "third_party/skia/include/core/SkRegion.h"
 #include "ui/aura/client/activation_change_observer.h"
 #include "ui/aura/client/activation_delegate.h"
@@ skipping 42 matching lines @@
       public gfx::DisplayObserver,
       public aura::RootWindowObserver,
       public aura::WindowDelegate,
       public aura::client::ActivationDelegate,
       public aura::client::ActivationChangeObserver,
       public aura::client::FocusChangeObserver,
       public aura::client::CursorClientObserver,
       public ImageTransportFactoryObserver,
       public BrowserAccessibilityDelegate,
       public FrameContainer,
-      public base::SupportsWeakPtr<RenderWidgetHostViewAura> {
+      public base::SupportsWeakPtr<RenderWidgetHostViewAura>,
+      public cc::DelegatedFrameResourceCollectionClient {
  public:
   // Used to notify whenever the paint-content of the view changes.
   class PaintObserver {
    public:
     PaintObserver() {}
     virtual ~PaintObserver() {}
 
     // This is called when painting of the page is completed.
     virtual void OnPaintComplete() = 0;
 
@@ skipping 418 matching lines @@
       const BufferPresentedCallback& ack_callback,
       const scoped_refptr<ui::Texture>& texture_to_return);
 
   void SwapDelegatedFrame(
       uint32 output_surface_id,
       scoped_ptr<cc::DelegatedFrameData> frame_data,
       float frame_device_scale_factor,
       const ui::LatencyInfo& latency_info);
   void SendDelegatedFrameAck(uint32 output_surface_id);
 
-  void SwapSoftwareFrame(
-      uint32 output_surface_id,
-      scoped_ptr<cc::SoftwareFrameData> frame_data,
-      float frame_device_scale_factor,
-      const ui::LatencyInfo& latency_info);
+  // cc::DelegatedFrameProviderClient implementation.
+  virtual void UnusedResourcesAreAvailable() OVERRIDE;
+
+  void SwapSoftwareFrame(uint32 output_surface_id,
+                         scoped_ptr<cc::SoftwareFrameData> frame_data,
+                         float frame_device_scale_factor,
+                         const ui::LatencyInfo& latency_info);
   void SendSoftwareFrameAck(uint32 output_surface_id);
   void SendReclaimSoftwareFrames();
   void ReleaseSoftwareFrame(uint32 output_surface_id,
                             unsigned software_frame_id);
 
   void DidReceiveFrameFromRenderer();
 
   BrowserAccessibilityManager* GetOrCreateBrowserAccessibilityManager();
 
 #if defined(OS_WIN)
@@ skipping 78 matching lines @@
   // The damage in the previously presented buffer.
   SkRegion previous_damage_;
 
   // Pending damage from previous frames that we skipped.
   SkRegion skipped_damage_;
 
   // True after a delegated frame has been skipped, until a frame is not
   // skipped.
   bool skipped_frames_;
 
+  // Holds delegated resources that have been given to a DelegatedFrameProvider,
+  // and gives back resources when they are no longer in use for return to the
+  // renderer.
+  scoped_refptr<cc::DelegatedFrameResourceCollection> resource_collection_;
+
+  // Provides delegated frame updates to the cc::DelegatedRendererLayer.
+  scoped_refptr<cc::DelegatedFrameProvider> frame_provider_;
+
   // The size of the last frame that was swapped (even if we skipped it).
   // Used to determine when the skipped_damage_ needs to be reset due to
   // size changes between front- and backbuffer.
   gfx::Size last_swapped_surface_size_;
   float last_swapped_surface_scale_factor_;
 
   gfx::GLSurfaceHandle shared_surface_handle_;
 
   // If non-NULL we're in OnPaint() and this is the supplied canvas.
   gfx::Canvas* paint_canvas_;
@@ skipping 97 matching lines @@
     unsigned frame_id;
   };
   std::vector<ReleasedFrameInfo> released_software_frames_;
 
   DISALLOW_COPY_AND_ASSIGN(RenderWidgetHostViewAura);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_BROWSER_RENDERER_HOST_RENDER_WIDGET_HOST_VIEW_AURA_H_