Hook up ui::Compositor to Display's BeginFrameSource

cc/surfaces/display.h

Index: cc/surfaces/display.h
diff --git a/cc/surfaces/display.h b/cc/surfaces/display.h
index 4646179d0a4d0cd010f32b66f5fd7d06237415ed..9ec9da61a37cc96a2b664e903d2709c05cb0dddc 100644
--- a/cc/surfaces/display.h
+++ b/cc/surfaces/display.h
@@ -55,11 +55,12 @@ class CC_SURFACES_EXPORT Display : public DisplaySchedulerClient,
           SurfaceManager* manager,
           SharedBitmapManager* bitmap_manager,
           gpu::GpuMemoryBufferManager* gpu_memory_buffer_manager,
-          const RendererSettings& settings);
+          const RendererSettings& settings,
+          uint32_t compositor_surface_namespace);
   ~Display() override;
 
   bool Initialize(scoped_ptr<OutputSurface> output_surface,
-                  DisplayScheduler* scheduler);
+                  base::SingleThreadTaskRunner* task_runner);

[sunnyps, 2016/03/28 23:09:48]

nit: The task runner is base::ThreadTaskRunnerHandle except for tests. So
DisplayScheduler could have a static factory function that passes the right task
runner to its constructor.

[enne (OOO), 2016/03/29 20:39:52]

Where in the pipeline do you want me to change this? The SingleThreadTaskRunner
parameter goes GpuProcessTransportFactory -> OnScreenDisplayClient -> Display ->
DisplayScheduler -> BeginFrameSource.  Should I change all of these?

[enne (OOO), 2016/03/29 21:57:33]

Talked to danakj for base ownership guidance.  She said that explicit plumbing
of the task runner was better than using global accessors so that in the future
this could all be switched to using thread pools.  She suggested switching
SingleThreadTaskRunner to SequencedTaskRunner as well, but given things like
RenderThreadImpl local storage, I don't think the compositor is ready to be run
on multiple threads.

So, end result is that I'm going to leave this as-is.

[sunnyps, 2016/03/29 22:00:10]

Ok. Sounds good.

 
   // device_scale_factor is used to communicate to the external window system
   // what scale this was rendered at.
@@ -71,10 +72,12 @@ class CC_SURFACES_EXPORT Display : public DisplaySchedulerClient,
 
   // DisplaySchedulerClient implementation.
   bool DrawAndSwap() override;
+  void UpdateSchedulerBeginFrameSource(BeginFrameSource* source) override;
 
   // OutputSurfaceClient implementation.
   void CommitVSyncParameters(base::TimeTicks timebase,
-                             base::TimeDelta interval) override;
+                             base::TimeDelta interval) override {}
+  void SetBeginFrameSource(BeginFrameSource* source) override;
   void SetNeedsRedrawRect(const gfx::Rect& damage_rect) override;
   void DidSwapBuffers() override;
   void DidSwapBuffersComplete() override;
@@ -96,28 +99,37 @@ class CC_SURFACES_EXPORT Display : public DisplaySchedulerClient,
   // SurfaceDamageObserver implementation.
   void OnSurfaceDamaged(SurfaceId surface, bool* changed) override;
 
- private:
+ protected:
+  // Virtual for tests.
+  virtual void CreateScheduler(base::SingleThreadTaskRunner* task_runner);

[enne (OOO), 2016/03/28 21:43:27]

This used to be passed in, so that a test scheduler could be created, but that's
awkward with the way the begin frame source gets to the DisplayScheduler so now
there's a virtual to create this for the test that wants a TestDisplayScheduler.

+
   void InitializeRenderer();
   void UpdateRootSurfaceResourcesLocked();
 
   DisplayClient* client_;
-  SurfaceManager* manager_;
+  SurfaceManager* surface_manager_;
   SharedBitmapManager* bitmap_manager_;
   gpu::GpuMemoryBufferManager* gpu_memory_buffer_manager_;
   RendererSettings settings_;
   SurfaceId current_surface_id_;
+  uint32_t compositor_surface_namespace_;
   gfx::Size current_surface_size_;
   float device_scale_factor_;
   bool swapped_since_resize_;
   gfx::Rect external_clip_;
   scoped_ptr<OutputSurface> output_surface_;
-  DisplayScheduler* scheduler_;
+  scoped_ptr<DisplayScheduler> scheduler_;
+  // The real BFS tied to vsync provided by the BrowserCompositorOutputSurface.
+  BeginFrameSource* vsync_begin_frame_source_;
+  // The BFS that the scheduler wants to use for this display.
+  BeginFrameSource* scheduler_begin_frame_source_;
   scoped_ptr<ResourceProvider> resource_provider_;
   scoped_ptr<SurfaceAggregator> aggregator_;
   scoped_ptr<DirectRenderer> renderer_;
   scoped_ptr<TextureMailboxDeleter> texture_mailbox_deleter_;
   std::vector<ui::LatencyInfo> stored_latency_info_;
 
+ private:
   DISALLOW_COPY_AND_ASSIGN(Display);
 };