Clean up DelegatedFrameHost's interface to its client

content/browser/compositor/delegated_frame_host.h

 // Copyright 2014 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_COMPOSITOR_DELEGATED_FRAME_HOST_H_
 #define CONTENT_BROWSER_COMPOSITOR_DELEGATED_FRAME_HOST_H_
 
 #include "cc/layers/delegated_frame_provider.h"
 #include "cc/layers/delegated_frame_resource_collection.h"
 #include "cc/output/copy_output_result.h"
@@ skipping 26 matching lines @@
 class ReadbackYUVInterface;
 class RenderWidgetHostViewFrameSubscriber;
 class RenderWidgetHostImpl;
 class ResizeLock;
 
 // The DelegatedFrameHostClient is the interface from the DelegatedFrameHost,
 // which manages delegated frames, and the ui::Compositor being used to
 // display them.
 class CONTENT_EXPORT DelegatedFrameHostClient {
  public:
-  virtual ui::Layer* GetLayer() = 0;
-  virtual RenderWidgetHostImpl* GetHost() = 0;
-  virtual bool IsVisible() = 0;
-  virtual scoped_ptr<ResizeLock> CreateResizeLock(
+  virtual bool DelegatedFrameHostIsVisible() const = 0;
+  virtual gfx::Size DelegatedFrameHostDesiredSizeInDIP() const = 0;
+
+  virtual bool DelegatedFrameCanCreateResizeLock() const = 0;
+  virtual scoped_ptr<ResizeLock> DelegatedFrameHostCreateResizeLock(
       bool defer_compositor_lock) = 0;
-  virtual gfx::Size DesiredFrameSize() = 0;
+  virtual void DelegatedFrameHostResizeLockWasReleased() = 0;
 
-  // TODO(ccameron): It is likely that at least one of these two functions is
-  // redundant. Find which one, and delete it.
-  virtual float CurrentDeviceScaleFactor() = 0;
-  virtual gfx::Size ConvertViewSizeToPixel(const gfx::Size& size) = 0;
+  virtual void DelegatedFrameHostSendCompositorSwapAck(
+      int output_surface_id,
+      const cc::CompositorFrameAck& ack) = 0;
+  virtual void DelegatedFrameHostSendReclaimCompositorResources(
+      int output_surface_id,
+      const cc::CompositorFrameAck& ack) = 0;
+  virtual void DelegatedFrameHostOnLostCompositorResources() = 0;
 
-  // These are to be overridden for testing only.
-  // TODO(ccameron): This is convoluted. Make the tests that need to override
-  // these functions test DelegatedFrameHost directly (rather than do it
-  // through RenderWidgetHostViewAura).
-  virtual DelegatedFrameHost* GetDelegatedFrameHost() const = 0;
-  virtual bool ShouldCreateResizeLock();
-  virtual void RequestCopyOfOutput(scoped_ptr<cc::CopyOutputRequest> request);
+  virtual void DelegatedFrameHostUpdateVSyncParameters(
+      const base::TimeTicks& timebase,
+      const base::TimeDelta& interval) = 0;
 };
 
 // The DelegatedFrameHost is used to host all of the RenderWidgetHostView state
 // and functionality that is associated with delegated frames being sent from
 // the RenderWidget. The DelegatedFrameHost will push these changes through to
 // the ui::Compositor associated with its DelegatedFrameHostClient.
 class CONTENT_EXPORT DelegatedFrameHost
     : public ui::CompositorObserver,
       public ui::CompositorVSyncManager::Observer,
       public ui::LayerOwnerDelegate,
       public ImageTransportFactoryObserver,
       public DelegatedFrameEvictorClient,
       public cc::DelegatedFrameResourceCollectionClient,
       public cc::SurfaceFactoryClient,
       public base::SupportsWeakPtr<DelegatedFrameHost> {
  public:
-  DelegatedFrameHost(DelegatedFrameHostClient* client);
+  DelegatedFrameHost(DelegatedFrameHostClient* client, ui::Layer* layer);
   ~DelegatedFrameHost() override;
 
   bool CanCopyToBitmap() const;
 
   // Public interface exposed to RenderWidgetHostView.
   void SwapDelegatedFrame(
       uint32 output_surface_id,
       scoped_ptr<cc::DelegatedFrameData> frame_data,
       float frame_device_scale_factor,
       const std::vector<ui::LatencyInfo>& latency_info);
@@ skipping 20 matching lines @@
   bool HasFrameSubscriber() const { return frame_subscriber_; }
 
   // Exposed for tests.
   cc::DelegatedFrameProvider* FrameProviderForTesting() const {
     return frame_provider_.get();
   }
   cc::SurfaceId SurfaceIdForTesting() const { return surface_id_; }
   void OnCompositingDidCommitForTesting(ui::Compositor* compositor) {
     OnCompositingDidCommit(compositor);
   }
-  bool ShouldCreateResizeLockForTesting() { return ShouldCreateResizeLock(); }
   bool ReleasedFrontLockActiveForTesting() const {
     return !!released_front_lock_.get();
   }
+  void SetRequestCopyOfOutputCallbackForTesting(
+      const base::Callback<void(scoped_ptr<cc::CopyOutputRequest>)>& callback) {
+    request_copy_of_output_callback_for_testing_ = callback;
+  }
 
  private:
   friend class DelegatedFrameHostClient;
   FRIEND_TEST_ALL_PREFIXES(RenderWidgetHostViewAuraTest,
                            SkippedDelegatedFrames);
   FRIEND_TEST_ALL_PREFIXES(RenderWidgetHostViewAuraTest,
                            DiscardDelegatedFramesWithLocking);
   FRIEND_TEST_ALL_PREFIXES(RenderWidgetHostViewAuraCopyRequestTest,
                            DestroyedAfterCopyRequest);
 
   RenderWidgetHostViewFrameSubscriber* frame_subscriber() const {
     return frame_subscriber_.get();
   }
   bool ShouldCreateResizeLock();
-  void RequestCopyOfOutput(scoped_ptr<cc::CopyOutputRequest> request);
-
   void LockResources();
   void UnlockResources();
+  void RequestCopyOfOutput(scoped_ptr<cc::CopyOutputRequest> request);
 
   // Overridden from ui::CompositorObserver:
   void OnCompositingDidCommit(ui::Compositor* compositor) override;
   void OnCompositingStarted(ui::Compositor* compositor,
                             base::TimeTicks start_time) override;
   void OnCompositingEnded(ui::Compositor* compositor) override;
   void OnCompositingAborted(ui::Compositor* compositor) override;
   void OnCompositingLockStateChanged(ui::Compositor* compositor) override;
   void OnCompositingShuttingDown(ui::Compositor* compositor) override;
 
@@ skipping 64 matching lines @@
   void EvictDelegatedFrame() override;
 
   // cc::DelegatedFrameProviderClient implementation.
   void UnusedResourcesAreAvailable() override;
 
   // cc::SurfaceFactoryClient implementation.
   void ReturnResources(const cc::ReturnedResourceArray& resources) override;
 
   void DidReceiveFrameFromRenderer(const gfx::Rect& damage_rect);
 
-  DelegatedFrameHostClient* client_;
+  DelegatedFrameHostClient* const client_;
+  ui::Layer* const layer_;
 
   ui::Compositor* compositor_;
 
   // True if this renders into a Surface, false if it renders into a delegated
   // layer.
   bool use_surfaces_;
 
   std::vector<base::Closure> on_compositing_did_commit_callbacks_;
 
   // The vsync manager we are observing for changes, if any.
@@ skipping 58 matching lines @@
     NO_PENDING_COMMIT,
   };
   CanLockCompositorState can_lock_compositor_;
 
   base::TimeTicks last_draw_ended_;
 
   // Subscriber that listens to frame presentation events.
   scoped_ptr<RenderWidgetHostViewFrameSubscriber> frame_subscriber_;
   std::vector<scoped_refptr<OwnedMailbox> > idle_frame_subscriber_textures_;
 
+  // Callback used to pass the output request to the layer or to a function
+  // specified by a test.
+  base::Callback<void(scoped_ptr<cc::CopyOutputRequest>)>
+      request_copy_of_output_callback_for_testing_;
+
   // YUV readback pipeline.
   scoped_ptr<content::ReadbackYUVInterface>
       yuv_readback_pipeline_;
 
   scoped_ptr<DelegatedFrameEvictor> delegated_frame_evictor_;
 };
 
 }  // namespace content
 
 #endif  // CONTENT_BROWSER_COMPOSITOR_DELEGATED_FRAME_HOST_H_