Fork cc::OutputSurface into cc::CompositorFrameSink.

cc/scheduler/scheduler.h

 // Copyright 2011 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_SCHEDULER_SCHEDULER_H_
 #define CC_SCHEDULER_SCHEDULER_H_
 
 #include <deque>
 #include <memory>
 #include <string>
@@ skipping 24 matching lines @@
 
 class SchedulerClient {
  public:
   virtual void WillBeginImplFrame(const BeginFrameArgs& args) = 0;
   virtual void ScheduledActionSendBeginMainFrame(
       const BeginFrameArgs& args) = 0;
   virtual DrawResult ScheduledActionDrawAndSwapIfPossible() = 0;
   virtual DrawResult ScheduledActionDrawAndSwapForced() = 0;
   virtual void ScheduledActionCommit() = 0;
   virtual void ScheduledActionActivateSyncTree() = 0;
-  virtual void ScheduledActionBeginOutputSurfaceCreation() = 0;
+  virtual void ScheduledActionBeginCompositorFrameSinkCreation() = 0;
   virtual void ScheduledActionPrepareTiles() = 0;
-  virtual void ScheduledActionInvalidateOutputSurface() = 0;
+  virtual void ScheduledActionInvalidateCompositorFrameSink() = 0;
   virtual void DidFinishImplFrame() = 0;
   virtual void SendBeginMainFrameNotExpectedSoon() = 0;
 
  protected:
   virtual ~SchedulerClient() {}
 };
 
 class CC_EXPORT Scheduler : public BeginFrameObserverBase {
  public:
   static std::unique_ptr<Scheduler> Create(
       SchedulerClient* client,
       const SchedulerSettings& scheduler_settings,
       int layer_tree_host_id,
       base::SingleThreadTaskRunner* task_runner,
       BeginFrameSource* begin_frame_source,
       std::unique_ptr<CompositorTimingHistory> compositor_timing_history);
 
   ~Scheduler() override;
 
   // BeginFrameObserverBase
   void OnBeginFrameSourcePausedChanged(bool paused) override;
   bool OnBeginFrameDerivedImpl(const BeginFrameArgs& args) override;
 
-  void OnDrawForOutputSurface(bool resourceless_software_draw);
+  void OnDrawForCompositorFrameSink(bool resourceless_software_draw);
 
   const SchedulerSettings& settings() const { return settings_; }
 
   void SetEstimatedParentDrawTime(base::TimeDelta draw_time);
 
   void SetVisible(bool visible);
   bool visible() { return state_machine_.visible(); }
   void SetCanDraw(bool can_draw);
   void NotifyReadyToActivate();
   void NotifyReadyToDraw();
@@ skipping 13 matching lines @@
 
   void SetTreePrioritiesAndScrollState(TreePriority tree_priority,
                                        ScrollHandlerState scroll_handler_state);
 
   void NotifyReadyToCommit();
   void BeginMainFrameAborted(CommitEarlyOutReason reason);
   void DidCommit();
 
   void WillPrepareTiles();
   void DidPrepareTiles();
-  void DidLoseOutputSurface();
-  void DidCreateAndInitializeOutputSurface();
+  void DidLoseCompositorFrameSink();
+  void DidCreateAndInitializeCompositorFrameSink();
 
   // Tests do not want to shut down until all possible BeginMainFrames have
   // occured to prevent flakiness.
   bool MainFrameForTestingWillHappen() const {
     return state_machine_.CommitPending() ||
            state_machine_.CouldSendBeginMainFrame();
   }
 
   bool CommitPending() const { return state_machine_.CommitPending(); }
   bool RedrawPending() const { return state_machine_.RedrawPending(); }
@@ skipping 97 matching lines @@
   }
 
   base::WeakPtrFactory<Scheduler> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(Scheduler);
 };
 
 }  // namespace cc
 
 #endif  // CC_SCHEDULER_SCHEDULER_H_