Initial checkin of the new Mozart compositor.

services/gfx/compositor/backend/scheduler.h

+// Copyright 2015 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 SERVICES_GFX_COMPOSITOR_BACKEND_SCHEDULER_H_
+#define SERVICES_GFX_COMPOSITOR_BACKEND_SCHEDULER_H_
+
+#include <limits>
+#include <mutex>
+
+#include "base/callback.h"
+#include "base/macros.h"
+#include "mojo/services/gfx/composition/interfaces/scheduling.mojom.h"
+
+namespace compositor {
+
+// Determines the behavior of |ScheduleFrame()|.
+enum class SchedulingMode {

[viettrungluu, 2016/01/04 21:08:24]

Maybe this should be declared inside Scheduler? (Depends on how much you
envisage it being used separately from Scheduler, I guess.)

[jeffbrown, 2016/01/16 03:28:31]

I went back and forth on this.  I'll move it back in.

+  // Schedules a snapshot, at minimum.
+  kSnapshot,

[viettrungluu, 2016/01/04 21:08:24]

FYI: Typically, we've followed Chromium style, which uses FOO_BAR instead of
kFooBar for enum values (which is an older Google style). However, rumor has it
there are ongoing style discussions within Google (and relatedly also
Chromium)....

[jeffbrown, 2016/01/16 03:28:31]

Apparently the preferred style is now "kFoo" like other constants.

https://google.github.io/styleguide/cppguide.html#Enumerator_Names
"New code should prefer constant-style naming if possible."

+
+  // Schedules an update followed by a snapshot, at minimum.
+  kUpdateAndSnapshot,
+};
+
+// Interface implemented by schedulers.

[viettrungluu, 2016/01/04 21:08:24]

This comment is almost useless. :) It may be helpful to say what a scheduler
is....

[jeffbrown, 2016/01/16 03:28:31]

Done.

+class Scheduler {
+ public:
+  Scheduler() = default;
+  virtual ~Scheduler() = default;
+
+  // Schedules work for a frame.
+  //
+  // This function ensures that every update is followed by a snapshot
+  // unless scheduling is suspended in the meantime.
+  //
+  // When |scheduling_mode| is |kSnapshot|, if there is time between now
+  // and the snapshot during which an update can be performed, then an
+  // update will also be scheduled before the requested snapshot.
+  //
+  // When |scheduling_mode| is |kUpdateAndSnapshot|, if there is time
+  // between now and the update during which a snapshot can be performed,
+  // then a snapshot will also be scheduled before the requested update
+  // and the next snapshot.
+  //
+  // This design is intended to minimize latency by anticipating that
+  // snapshots will be needed after updates and by scheduling updates in
+  // advance if it is known that a snapshot will be needed on the next frame.
+  virtual void ScheduleFrame(SchedulingMode scheduling_mode) = 0;
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(Scheduler);
+};
+
+// Scheduling callbacks.
+struct SchedulerCallbacks {

[viettrungluu, 2016/01/04 21:08:23]

When/where is this used? (It's a bit odd that it's in this file, and not used by
Scheduler....)

[jeffbrown, 2016/01/16 03:28:31]

Added docs to make this clearer.

+  using FrameCallback =
+      base::Callback<void(const mojo::gfx::composition::FrameInfo&)>;
+
+  SchedulerCallbacks(const FrameCallback& update_callback,
+                     const FrameCallback& snapshot_callback);
+  ~SchedulerCallbacks();
+
+  // Called when it's time for applications to/ update the contents of
+  // their scenes.
+  const FrameCallback update_callback;
+
+  // Called when it's time for the compositor to snapshot and submit
+  // the next frame.
+  const FrameCallback snapshot_callback;
+};
+
+}  // namespace compositor
+
+#endif  // SERVICES_GFX_COMPOSITOR_BACKEND_SCHEDULER_H_