Support distributing vsync info with surfaces.

For now the vsync signal can be sent to the browser compositor, which will handle distributing it like before.

BUG=

Review URL: https://codereview.chromium.org/568763004

Cr-Commit-Position: refs/heads/master@{#296126}

cc/surfaces/display.cc

@@ -140,6 +140,11 @@ void Display::DidSwapBuffersComplete() {
   client_->DidSwapBuffersComplete();
 }
 
+void Display::CommitVSyncParameters(base::TimeTicks timebase,
+                                    base::TimeDelta interval) {
+  client_->CommitVSyncParameters(timebase, interval);
+}
+
 void Display::OnSurfaceDamaged(SurfaceId surface) {
   if (aggregator_ && aggregator_->previous_contained_surfaces().count(surface))
     client_->DisplayDamaged();

cc/surfaces/display.h

@@ -53,7 +53,7 @@ class CC_SURFACES_EXPORT Display : public OutputSurfaceClient,
   virtual void DeferredInitialize() OVERRIDE {}
   virtual void ReleaseGL() OVERRIDE {}
   virtual void CommitVSyncParameters(base::TimeTicks timebase,
-                                     base::TimeDelta interval) OVERRIDE {}
+                                     base::TimeDelta interval) OVERRIDE;
   virtual void SetNeedsRedrawRect(const gfx::Rect& damage_rect) OVERRIDE {}
   virtual void BeginFrame(const BeginFrameArgs& args) OVERRIDE {}
   virtual void DidSwapBuffers() OVERRIDE;

cc/surfaces/display_client.h

@@ -6,6 +6,7 @@
 #define CC_SURFACES_DISPLAY_CLIENT_H_
 
 #include "base/memory/scoped_ptr.h"
+#include "base/time/time.h"
 
 namespace cc {
 
@@ -17,6 +18,8 @@ class DisplayClient {
   virtual void DisplayDamaged() = 0;
   virtual void DidSwapBuffers() = 0;
   virtual void DidSwapBuffersComplete() = 0;
+  virtual void CommitVSyncParameters(base::TimeTicks timebase,
+                                     base::TimeDelta interval) = 0;
 
  protected:
   virtual ~DisplayClient() {}

content/browser/compositor/gpu_process_transport_factory.cc

@@ -210,6 +210,7 @@ scoped_ptr<cc::OutputSurface> GpuProcessTransportFactory::CreateOutputSurface(
         new SurfaceDisplayOutputSurface(manager,
           next_surface_id_namespace_++,
           offscreen_context_provider));
+    display_client->set_surface_output_surface(output_surface.get());
     output_surface->set_display(display_client->display());
     data->display_client = display_client.Pass();
     return output_surface.PassAs<cc::OutputSurface>();

content/browser/compositor/onscreen_display_client.cc

@@ -8,6 +8,7 @@
 #include "cc/output/output_surface.h"
 #include "cc/surfaces/surface_factory.h"
 #include "cc/surfaces/surface_manager.h"
+#include "content/browser/compositor/surface_display_output_surface.h"
 #include "content/common/host_shared_bitmap_manager.h"
 
 namespace content {
@@ -34,6 +35,11 @@ scoped_ptr<cc::OutputSurface> OnscreenDisplayClient::CreateOutputSurface() {
   return output_surface_.Pass();
 }
 
+void OnscreenDisplayClient::CommitVSyncParameters(base::TimeTicks timebase,
+                                                  base::TimeDelta interval) {
+  surface_display_output_surface_->ReceivedVSyncParameters(timebase, interval);
+}
+
 void OnscreenDisplayClient::DisplayDamaged() {
   if (scheduled_draw_ || deferred_draw_)
     return;

content/browser/compositor/onscreen_display_client.h

@@ -18,6 +18,7 @@ class SurfaceManager;
 }
 
 namespace content {
+class SurfaceDisplayOutputSurface;
 
 // This class provides a DisplayClient implementation for drawing directly to an
 // onscreen context.
@@ -30,12 +31,17 @@ class OnscreenDisplayClient : cc::DisplayClient {
   virtual ~OnscreenDisplayClient();
 
   cc::Display* display() { return display_.get(); }
+  void set_surface_output_surface(SurfaceDisplayOutputSurface* surface) {
+    surface_display_output_surface_ = surface;
+  }
 
   // cc::DisplayClient implementation.
   virtual scoped_ptr<cc::OutputSurface> CreateOutputSurface() OVERRIDE;
   virtual void DisplayDamaged() OVERRIDE;
   virtual void DidSwapBuffers() OVERRIDE;
   virtual void DidSwapBuffersComplete() OVERRIDE;
+  virtual void CommitVSyncParameters(base::TimeTicks timebase,
+                                     base::TimeDelta interval) OVERRIDE;
 
  private:
   void ScheduleDraw();
@@ -44,6 +50,7 @@ class OnscreenDisplayClient : cc::DisplayClient {
   scoped_ptr<cc::OutputSurface> output_surface_;
   scoped_ptr<cc::Display> display_;
   scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
+  SurfaceDisplayOutputSurface* surface_display_output_surface_;
   bool scheduled_draw_;
   // True if a draw should be scheduled, but it's hit the limit on max frames
   // pending.

content/browser/compositor/surface_display_output_surface.cc

@@ -33,6 +33,12 @@ SurfaceDisplayOutputSurface::~SurfaceDisplayOutputSurface() {
   }
 }
 
+void SurfaceDisplayOutputSurface::ReceivedVSyncParameters(
+    base::TimeTicks timebase,
+    base::TimeDelta interval) {
+  CommitVSyncParameters(timebase, interval);
+}
+
 void SurfaceDisplayOutputSurface::SwapBuffers(cc::CompositorFrame* frame) {
   gfx::Size frame_size =
       frame->delegated_frame_data->render_pass_list.back()->output_rect.size();

content/browser/compositor/surface_display_output_surface.h

@@ -32,6 +32,8 @@ class SurfaceDisplayOutputSurface : public cc::OutputSurface,
 
   void set_display(cc::Display* display) { display_ = display; }
   cc::SurfaceFactory* factory() { return &factory_; }
+  void ReceivedVSyncParameters(base::TimeTicks timebase,
+                               base::TimeDelta interval);
 
   // cc::OutputSurface implementation.
   virtual void SwapBuffers(cc::CompositorFrame* frame) OVERRIDE;

mojo/services/surfaces/surfaces_impl.cc

@@ -104,4 +104,8 @@ void SurfacesImpl::DidSwapBuffers() {
 void SurfacesImpl::DidSwapBuffersComplete() {
 }
 
+void SurfacesImpl::CommitVSyncParameters(base::TimeTicks timebase,
+                                         base::TimeDelta interval) {
+}
+
 }  // namespace mojo

mojo/services/surfaces/surfaces_impl.h

@@ -54,6 +54,8 @@ class SurfacesImpl : public InterfaceImpl<Surface>,
   virtual void DisplayDamaged() OVERRIDE;
   virtual void DidSwapBuffers() OVERRIDE;
   virtual void DidSwapBuffersComplete() OVERRIDE;
+  virtual void CommitVSyncParameters(base::TimeTicks timebase,
+                                     base::TimeDelta interval) OVERRIDE;
 
   cc::SurfaceFactory* factory() { return &factory_; }