Mozart: Ensure time always runs forward.

services/gfx/compositor/graph/universe.h

+// Copyright 2016 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_GRAPH_UNIVERSE_H_
+#define SERVICES_GFX_COMPOSITOR_GRAPH_UNIVERSE_H_
+
+#include <deque>
+#include <iosfwd>
+
+#include "base/macros.h"
+#include "base/memory/ref_counted.h"
+#include "services/gfx/compositor/graph/scene_label.h"
+#include "services/gfx/compositor/graph/snapshot.h"
+
+namespace compositor {
+
+class SceneContent;
+class Snapshot;
+
+// Manages all active or pending versions of all scenes in the entire universe.
+//
+// Currently there is only one instance of the universe (this could change
+// someday).  Its job is to efficiently build snapshots for rendering
+// subject to the following invariants.
+//
+// 1. Scene state evolution always progresses forwards in time.  At no time
+//    will an older version of a scene be included in a snapshot once a
+//    newer version becomes unblocked.  This is true even when the scene is
+//    being rendered in multiple places.
+//
+// 2. A scene dependency which does not specify an explicit version (by
+//    passing |kSceneVersionNone|) will never be blocked as long as the
+//    dependent scene still exists and has published at least one unblocked
+//    version.  (Clients should watch for |OnResourceUnavailable| to handle
+//    the case where a dependent scene spontaneously becomes unavailable.)
+//
+// 3. A scene dependency which specifies an explicit version may become
+//    blocked or unblocked as the dependent scene publishes newer unblocked
+//    scene versions.
+//
+// 4. Scene dependency cycles are resolved by considering all scenes within
+//    the cycle to be blocked.  This guarantees consistent behavior regardless
+//    of how the cycle is entered.
+//
+// TODO(jeffbrown): In principle this object could keep track of scene
+// invalidations and incremental updates.
+class Universe {
+ public:
+  Universe();
+  ~Universe();
+
+  void AddScene(const SceneLabel& scene_label);
+  void PresentScene(const scoped_refptr<const SceneContent>& content);
+  void RemoveScene(const mojo::gfx::composition::SceneToken& scene_token);
+
+  scoped_refptr<const Snapshot> SnapshotScene(
+      const mojo::gfx::composition::SceneToken& scene_token,
+      uint32_t version,
+      std::ostream* block_log);
+
+ private:
+  struct SceneInfo {
+    SceneInfo(const SceneLabel& label);
+    ~SceneInfo();
+
+    SceneLabel label;
+
+    // Set to the current generation when the queue was last updated.
+    // TODO(jeffbrown): We should perform more fine-grained invalidation of
+    // scenes based on their dependencies.
+    uint64_t update_generation = 0u;
+    Snapshot::Disposition disposition = Snapshot::Disposition::kBlocked;
+    std::deque<scoped_refptr<const SceneContent>> content_queue;
+  };
+
+  class Snapshotter : public SnapshotBuilder {
+   public:
+    Snapshotter(Universe* universe, std::ostream* block_log);
+    ~Snapshotter() override;
+
+   protected:
+    Snapshot::Disposition ResolveAndSnapshotScene(
+        const mojo::gfx::composition::SceneToken& scene_token,
+        uint32_t version,
+        scoped_refptr<const SceneContent>* out_content) override;
+
+   private:
+    Universe* universe_;
+    SceneInfo* cycle_ = nullptr;
+
+    DISALLOW_COPY_AND_ASSIGN(Snapshotter);
+  };
+
+  std::unordered_map<uint32_t, std::unique_ptr<SceneInfo>> scenes_;
+  uint64_t generation_ = 0u;
+
+  DISALLOW_COPY_AND_ASSIGN(Universe);
+};
+
+}  // namespace compositor
+
+#endif  // SERVICES_GFX_COMPOSITOR_GRAPH_UNIVERSE_H_