Hook up ui::Compositor to Display's BeginFrameSource

cc/surfaces/display.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 CC_SURFACES_DISPLAY_H_
 #define CC_SURFACES_DISPLAY_H_
 
 #include <vector>
 
 #include "base/macros.h"
@@ skipping 37 matching lines @@
 // surface IDs used to draw into the display and deciding when to draw.
 class CC_SURFACES_EXPORT Display : public DisplaySchedulerClient,
                                    public OutputSurfaceClient,
                                    public RendererClient,
                                    public SurfaceDamageObserver {
  public:
   Display(DisplayClient* client,
           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.
   void SetSurfaceId(SurfaceId id, float device_scale_factor);
   void Resize(const gfx::Size& new_size);
   void SetExternalClip(const gfx::Rect& clip);
 
   SurfaceId CurrentSurfaceId();
 
   // 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;
   void ReclaimResources(const CompositorFrameAck* ack) override;
   void DidLoseOutputSurface() override;
   void SetExternalTilePriorityConstraints(
       const gfx::Rect& viewport_rect,
       const gfx::Transform& transform) override;
   void SetMemoryPolicy(const ManagedMemoryPolicy& policy) override;
   void SetTreeActivationCallback(const base::Closure& callback) override;
   void OnDraw(const gfx::Transform& transform,
               const gfx::Rect& viewport,
               const gfx::Rect& clip,
               bool resourceless_software_draw) override;
 
   // RendererClient implementation.
   void SetFullRootLayerDamage() override;
 
   // 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);
 };
 
 }  // namespace cc
 
 #endif  // CC_SURFACES_DISPLAY_H_