Hook up ui::Compositor to Display's BeginFrameSource

cc/output/output_surface_client.h

 // Copyright 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 CC_OUTPUT_OUTPUT_SURFACE_CLIENT_H_
 #define CC_OUTPUT_OUTPUT_SURFACE_CLIENT_H_
 
 #include "base/callback.h"
 #include "base/memory/ref_counted.h"
 #include "base/time/time.h"
 #include "cc/base/cc_export.h"
 #include "cc/output/context_provider.h"
 #include "ui/gfx/geometry/rect.h"
 
 namespace gfx {
 class Transform;
 }
 
 namespace cc {
 
+class BeginFrameSource;
 class CompositorFrameAck;
 struct ManagedMemoryPolicy;
 
 class CC_EXPORT OutputSurfaceClient {
  public:
+  // TODO(enne): Remove this in favor of using SetBeginFrameSource.
   virtual void CommitVSyncParameters(base::TimeTicks timebase,

[sunnyps, 2016/04/01 22:35:25]

nit: This only calls CommitVSyncParameters on the client. So maybe we can remove
this and move the call to the client to the renderer's output surface?

[enne (OOO), 2016/04/02 00:18:38]

I think you're going to need to be more specific with what you're suggesting
here.

The vsync path needs to stick around for a while until enable begin frame
scheduling is turned on everywhere.  Also, begin frame sources live outside of
output surfaces in the renderer at the moment.  So the path to set vsync
parameters on the renderer begin frame source is roughly
BrowserCompositorOutputSurface -> CompositorVSyncManager -> DelegatedFrameHost
-> RenderWidgetHostViewAura -> RenderWidgetHostImpl ->
ViewMsg_UpdateVSyncParameters -> CompositorOutputSurface -> OutputSurfaceClient
/ LayerTreeHostImpl -> ProxyImpl -> SyntheticBeginFrameSource.

I think you're suggesting moving the CommitVSyncParameters call off of the
client interface (OutputSurfaceClient) and have the renderer's OutputSurface
(CompositorOutputSurface, usually) call the client (LayerTreeHostImpl) directly.
 Unfortunately, not every OutputSurface is a CompositorOutputSurface and the
creator of CompositorOutputSurface (RenderWidget) doesn't know about
LayerTreeHostImpl, so I'd need to add some "SetLayerTreeHostImpl" virtual that
only CompositorOutputSurface would implement? I can't quite picture what this
would look like.

I think in any case, this will go away soon on its own.  I also want to hoist
the ownership of external/synthetic begin frame sources into the output surfaces
themselves as a cleanup, which would also get rid of this client call.

[sunnyps, 2016/04/02 00:47:15]

Sorry for the confusion, I thought I was looking at output_surface.h.

I was suggesting that we remove OutputSurface::CommitVSyncParameters (which just
calls the same method on the client) and that
CompositorOutputSurface::OnUpdateVSyncParametersFromBrowser call
OutputSurfaceClient::CommitVSyncParameters.

[enne (OOO), 2016/04/04 18:12:32]

Oh!  Good thought.  Done.  :)

                                      base::TimeDelta interval) = 0;
+  // Pass the begin frame source for the client to observe.  Client does not own
+  // the BeginFrameSource.  OutputSurface should call this once after binding to
+  // the client and then call again with a null while detaching.
+  virtual void SetBeginFrameSource(BeginFrameSource* source) = 0;
+
   virtual void SetNeedsRedrawRect(const gfx::Rect& damage_rect) = 0;
   virtual void DidSwapBuffers() = 0;
   virtual void DidSwapBuffersComplete() = 0;
   virtual void ReclaimResources(const CompositorFrameAck* ack) = 0;
   virtual void DidLoseOutputSurface() = 0;
   virtual void SetExternalTilePriorityConstraints(
       const gfx::Rect& viewport_rect,
       const gfx::Transform& transform) = 0;
   virtual void SetMemoryPolicy(const ManagedMemoryPolicy& policy) = 0;
   // If set, |callback| will be called subsequent to each new tree activation,
   // regardless of the compositor visibility or damage. |callback| must remain
   // valid for the lifetime of the OutputSurfaceClient or until unregisted --
   // use SetTreeActivationCallback(base::Closure()) to unregister it.
   virtual void SetTreeActivationCallback(const base::Closure& callback) = 0;
-  // This allows the output surface to ask it's client for a draw.
+  // This allows the output surface to ask its client for a draw.
   virtual void OnDraw(const gfx::Transform& transform,
                       const gfx::Rect& viewport,
                       const gfx::Rect& clip,
                       bool resourceless_software_draw) = 0;
 
  protected:
   virtual ~OutputSurfaceClient() {}
 };
 
 }  // namespace cc
 
 #endif  // CC_OUTPUT_OUTPUT_SURFACE_CLIENT_H_