DelegatedFrameHost should not create an ExternalBeginFrameSource

content/browser/renderer_host/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_RENDERER_HOST_DELEGATED_FRAME_HOST_H_
 #define CONTENT_BROWSER_RENDERER_HOST_DELEGATED_FRAME_HOST_H_
 
 #include <stdint.h>
 
 #include <vector>
@@ skipping 57 matching lines @@
   virtual bool DelegatedFrameCanCreateResizeLock() const = 0;
   virtual std::unique_ptr<ResizeLock> DelegatedFrameHostCreateResizeLock(
       bool defer_compositor_lock) = 0;
   virtual void DelegatedFrameHostResizeLockWasReleased() = 0;
 
   virtual void DelegatedFrameHostSendReclaimCompositorResources(
       int compositor_frame_sink_id,
       bool is_swap_ack,
       const cc::ReturnedResourceArray& resources) = 0;
 
-  virtual void SetBeginFrameSource(cc::BeginFrameSource* source) = 0;
+  virtual void OnBeginFrame(const cc::BeginFrameArgs& args) = 0;
   virtual bool IsAutoResizeEnabled() const = 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::ContextFactoryObserver,
       public DelegatedFrameEvictorClient,
       public NON_EXPORTED_BASE(cc::CompositorFrameSinkSupportClient),
-      public cc::ExternalBeginFrameSourceClient,
       public base::SupportsWeakPtr<DelegatedFrameHost> {
  public:
   DelegatedFrameHost(const cc::FrameSinkId& frame_sink_id,
                      DelegatedFrameHostClient* client);
   ~DelegatedFrameHost() override;
 
   // ui::CompositorObserver implementation.
   void OnCompositingDidCommit(ui::Compositor* compositor) override;
   void OnCompositingStarted(ui::Compositor* compositor,
                             base::TimeTicks start_time) override;
@@ skipping 64 matching lines @@
 
   // Given a RenderWidgetHostViewBase that renders to a Surface that is
   // contained within this class' Surface, find the relative transform between
   // the Surfaces and apply it to a point. Returns false if a Surface has not
   // yet been created or if |target_view| is not a descendant RWHV from our
   // client.
   bool TransformPointToCoordSpaceForView(const gfx::Point& point,
                                          RenderWidgetHostViewBase* target_view,
                                          gfx::Point* transformed_point);
 
+  void SetNeedsBeginFrames(bool needs_begin_frames);
+  void BeginFrameDidNotSwap(const cc::BeginFrameAck& ack);
+
   // Exposed for tests.
   cc::SurfaceId SurfaceIdForTesting() const {
     return cc::SurfaceId(frame_sink_id_, local_surface_id_);
   }
 
   bool HasFrameForTesting() const { return has_frame_; }
 
   void OnCompositingDidCommitForTesting(ui::Compositor* compositor) {
     OnCompositingDidCommit(compositor);
   }
@@ skipping 54 matching lines @@
       bool result);
   static void ReturnSubscriberTexture(
       base::WeakPtr<DelegatedFrameHost> rwhva,
       scoped_refptr<OwnedMailbox> subscriber_texture,
       const gpu::SyncToken& sync_token);
 
   // Called to consult the current |frame_subscriber_|, to determine and maybe
   // initiate a copy-into-video-frame request.
   void AttemptFrameSubscriberCapture(const gfx::Rect& damage_rect);
 
-  // cc::ExternalBeginFrameSource implementation.
-  void OnNeedsBeginFrames(bool needs_begin_frames) override;
-  void OnDidFinishFrame(const cc::BeginFrameAck& ack) override;
-
   void CreateCompositorFrameSinkSupport();
   void ResetCompositorFrameSinkSupport();
 
+  void DidFinishFrame(const cc::BeginFrameAck& ack);
+
   const cc::FrameSinkId frame_sink_id_;
   cc::LocalSurfaceId local_surface_id_;
   DelegatedFrameHostClient* const client_;
   ui::Compositor* compositor_;
 
   // The vsync manager we are observing for changes, if any.
   scoped_refptr<ui::CompositorVSyncManager> vsync_manager_;
 
   // The current VSync timebase and interval. These are zero until the first
   // call to SetVSyncParameters().
@@ skipping 58 matching lines @@
 
   // Callback used to pass the output request to the layer or to a function
   // specified by a test.
   base::Callback<void(std::unique_ptr<cc::CopyOutputRequest>)>
       request_copy_of_output_callback_for_testing_;
 
   // YUV readback pipeline.
   std::unique_ptr<display_compositor::ReadbackYUVInterface>
       yuv_readback_pipeline_;
 
-  std::unique_ptr<cc::ExternalBeginFrameSource> begin_frame_source_;
   bool needs_begin_frame_ = false;
   uint32_t latest_confirmed_begin_frame_source_id_ = 0;
   uint64_t latest_confirmed_begin_frame_sequence_number_ =
       cc::BeginFrameArgs::kInvalidFrameNumber;
 
   bool has_frame_ = false;
 
   std::unique_ptr<DelegatedFrameEvictor> delegated_frame_evictor_;
 };
 
 }  // namespace content
 
 #endif  // CONTENT_BROWSER_RENDERER_HOST_DELEGATED_FRAME_HOST_H_