Mozart: Ensure time always runs forward.

services/gfx/compositor/graph/scene_def.cc

 // 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.
 
 #include "services/gfx/compositor/graph/scene_def.h"
 
 #include <ostream>
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
 #include "base/strings/stringprintf.h"
 #include "mojo/services/gfx/composition/cpp/formatting.h"
 #include "mojo/skia/type_converters.h"
 #include "services/gfx/compositor/graph/scene_content.h"
 #include "services/gfx/compositor/graph/transform_pair.h"
+#include "services/gfx/compositor/graph/universe.h"
 #include "services/gfx/compositor/render/render_image.h"
 
 namespace compositor {
 
 namespace {
 // TODO(jeffbrown): Determine and document a more appropriate size limit
 // for transferred images as part of the image pipe abstraction instead.
 const int32_t kMaxTextureWidth = 65536;
 const int32_t kMaxTextureHeight = 65536;
 
 void ReleaseMailboxTexture(
     mojo::gfx::composition::MailboxTextureCallbackPtr callback) {
   if (callback)
     callback->OnMailboxTextureReleased();
 }
 }  // namespace
 
-SceneDef::SceneDef(const SceneLabel& label)
-    : label_(label), weak_factory_(this) {}
+SceneDef::SceneDef(const SceneLabel& label) : label_(label) {}
 
 SceneDef::~SceneDef() {}
 
 void SceneDef::EnqueueUpdate(mojo::gfx::composition::SceneUpdatePtr update) {
   DCHECK(update);
   pending_updates_.push_back(update.Pass());
 }
 
 void SceneDef::EnqueuePublish(
     mojo::gfx::composition::SceneMetadataPtr metadata) {
   DCHECK(metadata);
   pending_publications_.emplace_back(new Publication(metadata.Pass()));
   pending_updates_.swap(pending_publications_.back()->updates);
 }
 
 SceneDef::Disposition SceneDef::Present(
     int64_t presentation_time,
+    Universe* universe,
     const SceneResolver& resolver,
     const SceneUnavailableSender& unavailable_sender,
     std::ostream& err) {
   // Walk backwards through the pending publications to find the index
   // just beyond the last one which is due to be presented at or before the
   // presentation time.
   size_t end = pending_publications_.size();
   for (;;) {
     if (!end)
       return Disposition::kUnchanged;
     if (pending_publications_[end - 1]->is_due(presentation_time))
       break;  // found last presentable publication
     end--;
   }
 
+  // TODO(jeffbrown): Should we publish every individual update to the
+  // universe or is it good enough to only capture the most recent
+  // accumulated updates at presentation time as we do here?
+
   // Apply all updates sequentially up to this point.
-  version_ = pending_publications_[end - 1]->metadata->version;
+  uint32_t version = pending_publications_[end - 1]->metadata->version;
   for (size_t index = 0; index < end; ++index) {
     for (auto& update : pending_publications_[index]->updates) {
       if (!ApplyUpdate(update.Pass(), resolver, unavailable_sender, err))
         return Disposition::kFailed;
     }
   }
 
   // Dequeue the publications we processed.
   pending_publications_.erase(pending_publications_.begin(),
                               pending_publications_.begin() + end);
 
-  // Rebuild the scene content, gathering all reachable nodes and resources
+  // Rebuild the scene content, collecting all reachable nodes and resources
   // and verifying that everything is correctly linked.
-  SceneContentBuilder builder(this, version_, err, resources_.size(),
-                              nodes_.size());
-  content_ = builder.Build();
-  return content_ ? Disposition::kSucceeded : Disposition::kFailed;
+  Collector collector(this, version, presentation_time, err);
+  scoped_refptr<const SceneContent> content = collector.Build();
+  if (!content)
+    return Disposition::kFailed;
+
+  universe->PresentScene(content);
+  return Disposition::kSucceeded;
 }
 
 bool SceneDef::ApplyUpdate(mojo::gfx::composition::SceneUpdatePtr update,
                            const SceneResolver& resolver,
                            const SceneUnavailableSender& unavailable_sender,
                            std::ostream& err) {
   DCHECK(update);
 
   // TODO(jeffbrown): We may be able to reuse some content from previous
   // versions even when the client removes and recreates resources or nodes.
@@ skipping 33 matching lines @@
       if (!node)
         return false;
       nodes_[node_id] = std::move(node);
     } else {
       nodes_.erase(node_id);
     }
   }
   return true;
 }
 
-bool SceneDef::UnlinkReferencedScene(
-    SceneDef* scene,
+void SceneDef::NotifySceneUnavailable(
+    const mojo::gfx::composition::SceneToken& scene_token,
     const SceneUnavailableSender& unavailable_sender) {
-  DCHECK(scene);
-
-  bool changed = false;
   for (auto& pair : resources_) {
     if (pair.second->type() == Resource::Type::kScene) {
       auto scene_resource =
           static_cast<const SceneResource*>(pair.second.get());
-      if (scene_resource->referenced_scene().get() == scene) {
-        changed = true;
-        pair.second = scene_resource->Unlink();
+      if (scene_resource->scene_token().value == scene_token.value)
         unavailable_sender.Run(pair.first);
-      }
     }
   }
-  return changed;
 }
 
 scoped_refptr<const Resource> SceneDef::CreateResource(
     uint32_t resource_id,
     mojo::gfx::composition::ResourcePtr resource_decl,
     const SceneResolver& resolver,
     const SceneUnavailableSender& unavailable_sender,
     std::ostream& err) {
   DCHECK(resource_decl);
 
   if (resource_decl->is_scene()) {
     auto& scene_resource_decl = resource_decl->get_scene();
     DCHECK(scene_resource_decl->scene_token);
 
     const mojo::gfx::composition::SceneToken& scene_token =
         *scene_resource_decl->scene_token;
-    base::WeakPtr<SceneDef> referenced_scene = resolver.Run(scene_token);
-    if (!referenced_scene)
+    if (!resolver.Run(scene_token))
       unavailable_sender.Run(resource_id);
-    return new SceneResource(scene_token, referenced_scene);
+    return new SceneResource(scene_token);
   }
 
   if (resource_decl->is_mailbox_texture()) {
     auto& mailbox_texture_resource_decl = resource_decl->get_mailbox_texture();
     DCHECK(mailbox_texture_resource_decl->mailbox_name.size() ==
            GL_MAILBOX_SIZE_CHROMIUM);
     DCHECK(mailbox_texture_resource_decl->size);
 
     const int32_t width = mailbox_texture_resource_decl->size->width;
     const int32_t height = mailbox_texture_resource_decl->size->height;
@@ skipping 99 matching lines @@
     return new LayerNode(node_id, std::move(content_transform),
                          content_clip.Pass(), hit_test_behavior.Pass(),
                          combinator, child_node_ids, layer_rect, blend.Pass());
   }
 
   err << "Unsupported node op type: node_id=" << node_id
       << ", node_op=" << node_decl->op;
   return nullptr;
 }
 
-const Node* SceneDef::FindNode(uint32_t node_id) const {
-  auto it = nodes_.find(node_id);
-  return it != nodes_.end() ? it->second.get() : nullptr;
+SceneDef::Collector::Collector(const SceneDef* scene,
+                               uint32_t version,
+                               int64_t presentation_time,
+                               std::ostream& err)
+    : SceneContentBuilder(scene->label_,
+                          version,
+                          presentation_time,
+                          scene->resources_.size(),
+                          scene->nodes_.size(),
+                          err),
+      scene_(scene) {
+  DCHECK(scene_);
 }
 
-const Resource* SceneDef::FindResource(uint32_t resource_id) const {
-  auto it = resources_.find(resource_id);
-  return it != resources_.end() ? it->second.get() : nullptr;
+SceneDef::Collector::~Collector() {}
+
+const Node* SceneDef::Collector::FindNode(uint32_t node_id) const {
+  auto it = scene_->nodes_.find(node_id);
+  return it != scene_->nodes_.end() ? it->second.get() : nullptr;
 }
 
-const SceneContent* SceneDef::FindContent(uint32_t version) const {
-  if (!content_)
-    return nullptr;
-
-  // TODO(jeffbrown): Consider briefly caching older versions to allow them
-  // to be used to provide alternate content for node combinators.
-  if (version != mojo::gfx::composition::kSceneVersionNone &&
-      version != content_->version() &&
-      content_->version() != mojo::gfx::composition::kSceneVersionNone)
-    return nullptr;
-  return content_.get();
+const Resource* SceneDef::Collector::FindResource(uint32_t resource_id) const {
+  auto it = scene_->resources_.find(resource_id);
+  return it != scene_->resources_.end() ? it->second.get() : nullptr;
 }
 
 SceneDef::Publication::Publication(
     mojo::gfx::composition::SceneMetadataPtr metadata)
     : metadata(metadata.Pass()) {
   DCHECK(this->metadata);
 }
 
 SceneDef::Publication::~Publication() {}
 
 }  // namespace compositor