Add DisplayScheduler for Surfaces

cc/surfaces/display_scheduler.h

Index: cc/surfaces/display_scheduler.h
diff --git a/cc/surfaces/display_scheduler.h b/cc/surfaces/display_scheduler.h
new file mode 100644
index 0000000000000000000000000000000000000000..e675683bf9443dc7052632f894d2c608d1c8eaec
--- /dev/null
+++ b/cc/surfaces/display_scheduler.h
@@ -0,0 +1,75 @@
+// 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_SCHEDULER_H_
+#define CC_SURFACES_DISPLAY_SCHEDULER_H_
+
+#include "base/cancelable_callback.h"
+#include "base/memory/ref_counted.h"
+#include "base/memory/scoped_ptr.h"
+#include "base/single_thread_task_runner.h"
+#include "cc/scheduler/begin_frame_source.h"
+#include "cc/surfaces/display.h"
+#include "cc/surfaces/surfaces_export.h"
+
+namespace cc {
+
+class CC_SURFACES_EXPORT DisplayScheduler : public BeginFrameObserverMixIn {
+ public:
+  DisplayScheduler(OutputSurface* output_surface,
+                   Display* display,
+                   scoped_refptr<base::SingleThreadTaskRunner> task_runner);
+  ~DisplayScheduler() override;
+
+  void EntireDisplayDamaged();
+  void SurfaceDamaged(SurfaceId surface_id);

[brianderson, 2015/04/03 01:35:48]

I split the generic SurfaceDamaged() into EntireDisplayDamaged() and
SurfaceDamaged(id) so we can roughly track which surfaces are active and wait
for them (or not wait for them when the entire display is damaged).

+  void DidSwapBuffers();
+  void DidSwapBuffersComplete();
+
+  void SetAuthoritativeVSyncInterval(const base::TimeDelta& interval);
+  void CommitVSyncParameters(base::TimeTicks timebase,
+                             base::TimeDelta interval);
+  void OutputSurfaceLost();
+
+  // BeginFrameObserverMixIn implementation
+  bool OnBeginFrameMixInDelegate(const BeginFrameArgs& args) override;
+
+ private:
+  base::TimeTicks DesiredBeginFrameDeadlineTime();
+  void ScheduleBeginFrameDeadline();
+  void OnBeginFrameDeadline();
+  void Draw();
+
+  OutputSurface* output_surface_;
+  Display* display_;
+  scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
+  scoped_ptr<BeginFrameSource> begin_frame_source_;
+  VSyncParameterObserver* vsync_observer_;
+  base::TimeDelta authoritative_vsync_interval_;
+  base::TimeTicks last_vsync_timebase_;
+
+  BeginFrameArgs current_begin_frame_args_;
+  base::Closure begin_impl_frame_deadline_closure_;
+  base::CancelableClosure begin_impl_frame_deadline_task_;
+  base::TimeTicks begin_impl_frame_deadline_task_time_;
+
+  bool output_surface_lost_;
+  bool inside_begin_frame_deadline_interval_;
+  bool needs_draw_;
+  bool entire_display_damaged_;
+  bool all_active_surfaces_ready_to_draw_;
+  int pending_frames_;
+
+  std::set<SurfaceId> surface_ids_damaged_;
+  std::set<SurfaceId> surface_ids_damaged_prev_;
+  std::vector<SurfaceId> surface_ids_to_expect_damage_from_;
+
+  base::WeakPtrFactory<DisplayScheduler> weak_ptr_factory_;
+
+  DISALLOW_COPY_AND_ASSIGN(DisplayScheduler);
+};
+
+}  // namespace cc
+
+#endif  // CC_SURFACES_DISPLAY_SCHEDULER_H_