Mozart: Ensure time always runs forward.

services/gfx/compositor/graph/scene_content.cc

 // 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.
 
 #include "services/gfx/compositor/graph/scene_content.h"
 
 #include <ostream>
 
 #include "base/logging.h"
 #include "services/gfx/compositor/graph/scene_def.h"
 
 namespace compositor {
 
 SceneContent::SceneContent(const SceneLabel& label,
                            uint32_t version,
+                           int64_t presentation_time,
                            size_t max_resources,
                            size_t max_nodes)
     : label_(label),
       version_(version),
+      presentation_time_(presentation_time),
       resources_(max_resources),
       nodes_(max_nodes) {}
 
 SceneContent::~SceneContent() {}
 
+bool SceneContent::MatchesVersion(uint32_t requested_version) const {
+  return requested_version == mojo::gfx::composition::kSceneVersionNone ||
+         requested_version == version_ ||
+         version_ == mojo::gfx::composition::kSceneVersionNone;
+}
+
 void SceneContent::RecordPicture(const Snapshot* snapshot,
                                  SkCanvas* canvas) const {
   const Node* root = GetRootNodeIfExists();
   if (root)
     root->RecordPicture(this, snapshot, canvas);
 }
 
 bool SceneContent::HitTest(
     const Snapshot* snapshot,
     const SkPoint& scene_point,
@@ skipping 32 matching lines @@
   auto it = nodes_.find(node_id);
   DCHECK(it != nodes_.end());
   return it->second.get();
 }
 
 const Node* SceneContent::GetRootNodeIfExists() const {
   auto it = nodes_.find(mojo::gfx::composition::kSceneRootNodeId);
   return it != nodes_.end() ? it->second.get() : nullptr;
 }
 
-SceneContentBuilder::SceneContentBuilder(const SceneDef* scene,
+SceneContentBuilder::SceneContentBuilder(const SceneLabel& label,
                                          uint32_t version,
-                                         std::ostream& err,
+                                         int64_t presentation_time,
                                          size_t max_resources,
-                                         size_t max_nodes)
-    : content_(
-          new SceneContent(scene->label(), version, max_resources, max_nodes)),
-      scene_(scene),
-      err_(err) {
-  DCHECK(scene);
-}
+                                         size_t max_nodes,
+                                         std::ostream& err)
+    : content_(new SceneContent(label,
+                                version,
+                                presentation_time,
+                                max_resources,
+                                max_nodes)),
+      err_(err) {}
 
 SceneContentBuilder::~SceneContentBuilder() {}
 
 const Resource* SceneContentBuilder::RequireResource(
     uint32_t resource_id,
     Resource::Type resource_type,
     uint32_t referrer_node_id) {
   DCHECK(content_);
 
   auto it = content_->resources_.find(resource_id);
   if (it != content_->resources_.end())
     return it->second.get();
 
-  const Resource* resource = scene_->FindResource(resource_id);
+  const Resource* resource = FindResource(resource_id);
   if (!resource) {
     err_ << "Missing resource " << resource_id << " referenced from node "
-         << content_->FormattedLabelForNode(referrer_node_id);
+         << content_->FormattedLabelForNode(referrer_node_id) << std::endl;
     return nullptr;
   }
 
   if (resource->type() != resource_type) {
     err_ << "Resource " << resource_id << " referenced from node "
          << content_->FormattedLabelForNode(referrer_node_id)
-         << " has incorrect type for its intended usage";
+         << " has incorrect type for its intended usage" << std::endl;
     return nullptr;
   }
 
   content_->resources_.emplace(std::make_pair(resource_id, resource));
   return resource;
 }
 
 const Node* SceneContentBuilder::RequireNode(uint32_t node_id,
                                              uint32_t referrer_node_id) {
   DCHECK(content_);
 
   auto it = content_->nodes_.find(node_id);
   if (it != content_->nodes_.end()) {
     if (it->second)
       return it->second.get();
     err_ << "Cycle detected at node " << node_id << " referenced from node "
-         << content_->FormattedLabelForNode(referrer_node_id);
+         << content_->FormattedLabelForNode(referrer_node_id) << std::endl;
     return nullptr;
   }
 
-  const Node* node = scene_->FindNode(node_id);
+  const Node* node = FindNode(node_id);
   if (!node) {
     err_ << "Missing node " << node_id << " referenced from node "
-         << content_->FormattedLabelForNode(referrer_node_id);
+         << content_->FormattedLabelForNode(referrer_node_id) << std::endl;
     return nullptr;
   }
 
   return AddNode(node) ? node : nullptr;
 }
 
 bool SceneContentBuilder::AddNode(const Node* node) {
   DCHECK(content_);
   DCHECK(node);
 
@@ skipping 14 matching lines @@
   // nodes may have been added since the map's bucket count was initialized
   // at creation time to the total number of nodes so it should never be
   // rehashed during this traversal.
   storage.first->second = node;
   return true;
 }
 
 scoped_refptr<const SceneContent> SceneContentBuilder::Build() {
   DCHECK(content_);
 
-  const Node* root = scene_->FindRootNode();
+  const Node* root = FindNode(mojo::gfx::composition::kSceneRootNodeId);
   return !root || AddNode(root) ? std::move(content_) : nullptr;
 }
 
 }  // namespace compositor