Mozart: Rename scene graph classes.

services/gfx/compositor/graph/snapshot.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/snapshot.h"
 
 #include "base/logging.h"
 #include "mojo/skia/type_converters.h"
 #include "services/gfx/compositor/graph/scene_content.h"
 #include "services/gfx/compositor/graph/scene_def.h"
@@ skipping 30 matching lines @@
 void Snapshot::HitTest(const mojo::PointF& point,
                        mojo::gfx::composition::HitTestResult* result) const {
   DCHECK(result);
   DCHECK(!is_blocked());
   DCHECK(root_scene_content_);
 
   root_scene_content_->HitTest(this, point.To<SkPoint>(), SkMatrix44::I(),
                                &result->root);
 }
 
-bool Snapshot::IsNodeBlocked(const NodeDef* node) const {
+bool Snapshot::IsNodeBlocked(const Node* node) const {
   DCHECK(!is_blocked());
 
   auto it = node_dispositions_.find(node);
   DCHECK(it != node_dispositions_.end());
   DCHECK(it->second == Disposition::kSuccess ||
          it->second == Disposition::kBlocked);
   return it->second == Disposition::kBlocked;
 }
 
 const SceneContent* Snapshot::GetResolvedSceneContent(
-    const SceneNodeDef* scene_node) const {
+    const SceneNode* scene_node) const {
   DCHECK(!is_blocked());
 
   auto it = resolved_scene_contents_.find(scene_node);
   DCHECK(it != resolved_scene_contents_.end());
   return it->second.get();
 }
 
 SnapshotBuilder::SnapshotBuilder(std::ostream* block_log)
     : block_log_(block_log), snapshot_(new Snapshot()) {}
 
 SnapshotBuilder::~SnapshotBuilder() {}
 
 Snapshot::Disposition SnapshotBuilder::SnapshotNode(
-    const NodeDef* node,
+    const Node* node,
     const SceneContent* content) {
   DCHECK(snapshot_);
   DCHECK(node);
   DCHECK(content);
   DCHECK(node != content->GetRootNodeIfExists());
 
   auto it = snapshot_->node_dispositions_.find(node);
   if (it != snapshot_->node_dispositions_.end())
     return it->second;
 
   Snapshot::Disposition disposition = node->RecordSnapshot(content, this);
   snapshot_->node_dispositions_[node] = disposition;
   return disposition;
 }
 
 Snapshot::Disposition SnapshotBuilder::SnapshotRootAndDetectCycles(
-    const NodeDef* node,
+    const Node* node,
     const SceneContent* content) {
   DCHECK(snapshot_);
   DCHECK(node);
   DCHECK(content);
   DCHECK(node == content->GetRootNodeIfExists());
 
   auto storage = snapshot_->node_dispositions_.emplace(
       node, Snapshot::Disposition::kCycle);
   if (!storage.second) {
     if (storage.first->second == Snapshot::Disposition::kCycle)
@@ skipping 21 matching lines @@
     if (cycle_ == content) {
       cycle_ = nullptr;  // found the ouroboros tail, stop unwinding
       disposition = Snapshot::Disposition::kBlocked;
     }
   }
   return disposition;
 }
 Snapshot::Disposition SnapshotBuilder::SnapshotScene(
     const SceneDef* scene,
     uint32_t version,
-    const SceneNodeDef* referrer_node,
+    const SceneNode* referrer_node,
     const SceneContent* referrer_content) {
   DCHECK(snapshot_);
   DCHECK(scene);
   DCHECK(referrer_node);
   DCHECK(referrer_content);
 
   // This function should only ever be called once when snapshotting the
-  // referring |SceneNodeDef| at which point the result will be memoized
+  // referring |SceneNode| at which point the result will be memoized
   // by |SnapshotNode| as usual so reentrance should not occur.
   DCHECK(snapshot_->resolved_scene_contents_.find(referrer_node) ==
          snapshot_->resolved_scene_contents_.end());
 
   snapshot_->dependencies_.insert(scene->label().token());
 
   const SceneContent* content = scene->FindContent(version);
   if (!content) {
     if (block_log_) {
       *block_log_ << "Scene node blocked because its referenced scene is not "
                      "available with the requested version: "
                   << referrer_node->FormattedLabel(referrer_content)
                   << ", scene " << scene->label().FormattedLabel()
                   << ", requested version " << version << ", current version "
                   << scene->version() << std::endl;
     }
     return Snapshot::Disposition::kBlocked;
   }
 
-  const NodeDef* root = content->GetRootNodeIfExists();
+  const Node* root = content->GetRootNodeIfExists();
   if (!root) {
     if (block_log_) {
       *block_log_ << "Scene node blocked because its referenced scene has no "
                      "root node: "
                   << referrer_node->FormattedLabel(referrer_content)
                   << ", scene " << content->FormattedLabel() << std::endl;
     }
     return Snapshot::Disposition::kBlocked;
   }
 
   snapshot_->resolved_scene_contents_[referrer_node] = content;
   return SnapshotRootAndDetectCycles(root, content);
 }
 
 Snapshot::Disposition SnapshotBuilder::SnapshotRenderer(const SceneDef* scene) {
   DCHECK(!snapshot_->root_scene_content_);
 
   snapshot_->dependencies_.insert(scene->label().token());
 
   const SceneContent* content =
       scene->FindContent(mojo::gfx::composition::kSceneVersionNone);
   if (!content) {
     if (block_log_) {
       *block_log_ << "Rendering blocked because the root scene has no content: "
                   << scene->label().FormattedLabel() << std::endl;
     }
     return Snapshot::Disposition::kBlocked;
   }
 
-  const NodeDef* root = content->GetRootNodeIfExists();
+  const Node* root = content->GetRootNodeIfExists();
   if (!root) {
     if (block_log_) {
       *block_log_ << "Rendering blocked the root scene has no root node: "
                   << content->FormattedLabel() << std::endl;
     }
     return Snapshot::Disposition::kBlocked;
   }
 
   snapshot_->root_scene_content_ = content;
   return SnapshotRootAndDetectCycles(root, content);
 }
 
 scoped_refptr<const Snapshot> SnapshotBuilder::Build(
     const SceneDef* root_scene) {
   DCHECK(snapshot_);
   DCHECK(root_scene);
 
   snapshot_->disposition_ = SnapshotRenderer(root_scene);
   DCHECK(!cycle_);  // must have properly unwound any cycles by now
 
   if (snapshot_->is_blocked()) {
     snapshot_->root_scene_content_ = nullptr;
     snapshot_->resolved_scene_contents_.clear();
     snapshot_->node_dispositions_.clear();
   }
   return std::move(snapshot_);
 }
 
 }  // namespace compositor