Mozart: Rename scene graph classes.

services/gfx/compositor/graph/nodes.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/node_def.h"
+#include "services/gfx/compositor/graph/nodes.h"
 
 #include <ostream>
 
 #include "base/logging.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/scene_def.h"
 #include "services/gfx/compositor/graph/snapshot.h"
 #include "services/gfx/compositor/graph/transform_pair.h"
@@ skipping 17 matching lines @@
   if (blend)
     paint->setAlpha(blend->alpha);
 }
 
 bool Contains(const SkRect& bounds, const SkPoint& point) {
   return point.x() >= bounds.left() && point.x() < bounds.right() &&
          point.y() >= bounds.top() && point.y() < bounds.bottom();
 }
 }  // namespace
 
-NodeDef::NodeDef(uint32_t node_id,
-                 std::unique_ptr<TransformPair> content_transform,
-                 mojo::RectFPtr content_clip,
-                 mojo::gfx::composition::HitTestBehaviorPtr hit_test_behavior,
-                 Combinator combinator,
-                 const std::vector<uint32_t>& child_node_ids)
+Node::Node(uint32_t node_id,
+           std::unique_ptr<TransformPair> content_transform,
+           mojo::RectFPtr content_clip,
+           mojo::gfx::composition::HitTestBehaviorPtr hit_test_behavior,
+           Combinator combinator,
+           const std::vector<uint32_t>& child_node_ids)
     : node_id_(node_id),
       content_transform_(std::move(content_transform)),
       content_clip_(content_clip.Pass()),
       hit_test_behavior_(hit_test_behavior.Pass()),
       combinator_(combinator),
       child_node_ids_(child_node_ids) {}
 
-NodeDef::~NodeDef() {}
+Node::~Node() {}
 
-std::string NodeDef::FormattedLabel(const SceneContent* content) const {
+std::string Node::FormattedLabel(const SceneContent* content) const {
   return content->FormattedLabelForNode(node_id_);
 }
 
-bool NodeDef::RecordContent(SceneContentBuilder* builder) const {
+bool Node::RecordContent(SceneContentBuilder* builder) const {
   DCHECK(builder);
 
   for (const auto& child_node_id : child_node_ids_) {
     if (!builder->RequireNode(child_node_id, node_id_))
       return false;
   }
   return true;
 }
 
-Snapshot::Disposition NodeDef::RecordSnapshot(const SceneContent* content,
-                                              SnapshotBuilder* builder) const {
+Snapshot::Disposition Node::RecordSnapshot(const SceneContent* content,
+                                           SnapshotBuilder* builder) const {
   DCHECK(content);
   DCHECK(builder);
 
   switch (combinator_) {
     // MERGE: All or nothing.
     case Combinator::MERGE: {
       for (uint32_t child_node_id : child_node_ids_) {
-        const NodeDef* child_node = content->GetNode(child_node_id);
+        const Node* child_node = content->GetNode(child_node_id);
         DCHECK(child_node);
         Snapshot::Disposition disposition =
             builder->SnapshotNode(child_node, content);
         if (disposition == Snapshot::Disposition::kCycle)
           return disposition;
         if (disposition == Snapshot::Disposition::kBlocked) {
           if (builder->block_log()) {
             *builder->block_log()
                 << "Node with MERGE combinator blocked since "
                    "one of its children is blocked: "
                 << FormattedLabel(content) << ", blocked child "
                 << child_node->FormattedLabel(content) << std::endl;
           }
           return disposition;
         }
       }
       return Snapshot::Disposition::kSuccess;
     }
 
     // PRUNE: Silently discard blocked children.
     case Combinator::PRUNE: {
       for (uint32_t child_node_id : child_node_ids_) {
-        const NodeDef* child_node = content->GetNode(child_node_id);
+        const Node* child_node = content->GetNode(child_node_id);
         DCHECK(child_node);
         Snapshot::Disposition disposition =
             builder->SnapshotNode(child_node, content);
         if (disposition == Snapshot::Disposition::kCycle)
           return disposition;
       }
       return Snapshot::Disposition::kSuccess;
     }
 
     // FALLBACK: Keep only the first unblocked child.
     case Combinator::FALLBACK: {
       if (child_node_ids_.empty())
         return Snapshot::Disposition::kSuccess;
       for (uint32_t child_node_id : child_node_ids_) {
-        const NodeDef* child_node = content->GetNode(child_node_id);
+        const Node* child_node = content->GetNode(child_node_id);
         DCHECK(child_node);
         Snapshot::Disposition disposition =
             builder->SnapshotNode(child_node, content);
         if (disposition != Snapshot::Disposition::kBlocked)
           return disposition;
       }
       if (builder->block_log()) {
         *builder->block_log() << "Node with FALLBACK combinator blocked since "
                                  "all of its children are blocked: "
                               << FormattedLabel(content) << std::endl;
       }
       return Snapshot::Disposition::kBlocked;
     }
 
     default: {
       if (builder->block_log()) {
         *builder->block_log()
             << "Unrecognized combinator: " << FormattedLabel(content)
             << std::endl;
       }
       return Snapshot::Disposition::kBlocked;
     }
   }
 }
 
 template <typename Func>
-void NodeDef::TraverseSnapshottedChildren(const SceneContent* content,
-                                          const Snapshot* snapshot,
-                                          const Func& func) const {
+void Node::TraverseSnapshottedChildren(const SceneContent* content,
+                                       const Snapshot* snapshot,
+                                       const Func& func) const {
   DCHECK(content);
   DCHECK(snapshot);
 
   switch (combinator_) {
     // MERGE: All or nothing.
     case Combinator::MERGE: {
       for (uint32_t child_node_id : child_node_ids_) {
-        const NodeDef* child_node = content->GetNode(child_node_id);
+        const Node* child_node = content->GetNode(child_node_id);
         DCHECK(child_node);
         DCHECK(!snapshot->IsNodeBlocked(child_node));
         if (!func(child_node))
           return;
       }
       return;
     }
 
     // PRUNE: Silently discard blocked children.
     case Combinator::PRUNE: {
       for (uint32_t child_node_id : child_node_ids_) {
-        const NodeDef* child_node = content->GetNode(child_node_id);
+        const Node* child_node = content->GetNode(child_node_id);
         DCHECK(child_node);
         if (!snapshot->IsNodeBlocked(child_node) && !func(child_node))
           return;
       }
       return;
     }
 
     // FALLBACK: Keep only the first unblocked child.
     case Combinator::FALLBACK: {
       if (child_node_ids_.empty())
         return;
       for (uint32_t child_node_id : child_node_ids_) {
-        const NodeDef* child_node = content->GetNode(child_node_id);
+        const Node* child_node = content->GetNode(child_node_id);
         DCHECK(child_node);
         if (!snapshot->IsNodeBlocked(child_node)) {
           func(child_node);  // don't care about the result because we
           return;            // always stop after the first one
         }
       }
       NOTREACHED();
       return;
     }
 
     default: {
       NOTREACHED();
       return;
     }
   }
 }
 
-void NodeDef::RecordPicture(const SceneContent* content,
-                            const Snapshot* snapshot,
-                            SkCanvas* canvas) const {
+void Node::RecordPicture(const SceneContent* content,
+                         const Snapshot* snapshot,
+                         SkCanvas* canvas) const {
   DCHECK(content);
   DCHECK(snapshot);
   DCHECK(canvas);
 
   const bool must_save = content_transform_ || content_clip_;
   if (must_save) {
     canvas->save();
     if (content_transform_)
       canvas->concat(content_transform_->forward());
     if (content_clip_)
       canvas->clipRect(content_clip_->To<SkRect>());
   }
 
   RecordPictureInner(content, snapshot, canvas);
 
   if (must_save)
     canvas->restore();
 }
 
-void NodeDef::RecordPictureInner(const SceneContent* content,
-                                 const Snapshot* snapshot,
-                                 SkCanvas* canvas) const {
+void Node::RecordPictureInner(const SceneContent* content,
+                              const Snapshot* snapshot,
+                              SkCanvas* canvas) const {
   DCHECK(content);
   DCHECK(snapshot);
   DCHECK(canvas);
 
   TraverseSnapshottedChildren(
       content, snapshot,
-      [this, content, snapshot, canvas](const NodeDef* child_node) -> bool {
+      [this, content, snapshot, canvas](const Node* child_node) -> bool {
         child_node->RecordPicture(content, snapshot, canvas);
         return true;
       });
 }
 
-bool NodeDef::HitTest(const SceneContent* content,
-                      const Snapshot* snapshot,
-                      const SkPoint& parent_point,
-                      const SkMatrix44& global_to_parent_transform,
-                      mojo::Array<mojo::gfx::composition::HitPtr>* hits) const {
+bool Node::HitTest(const SceneContent* content,
+                   const Snapshot* snapshot,
+                   const SkPoint& parent_point,
+                   const SkMatrix44& global_to_parent_transform,
+                   mojo::Array<mojo::gfx::composition::HitPtr>* hits) const {
   DCHECK(content);
   DCHECK(snapshot);
   DCHECK(hits);
 
   // TODO(jeffbrown): These calculations should probably be happening using
   // a 4x4 matrix instead.
   SkPoint local_point(parent_point);
   SkMatrix global_to_local_transform(global_to_parent_transform);
   if (content_transform_) {
     // TODO(jeffbrown): Defer matrix multiplications using a matrix stack.
     local_point = content_transform_->InverseMapPoint(parent_point);
     global_to_local_transform.preConcat(content_transform_->GetInverse());
   }
 
   if (content_clip_ && !Contains(content_clip_->To<SkRect>(), local_point))
     return false;
 
   bool opaque_children = false;
   if (!hit_test_behavior_ || !hit_test_behavior_->prune) {
     opaque_children = HitTestInner(content, snapshot, local_point,
                                    global_to_local_transform, hits);
   }
 
   return HitTestSelf(content, snapshot, local_point, global_to_local_transform,
                      hits) ||
          opaque_children;
 }
 
-bool NodeDef::HitTestInner(
+bool Node::HitTestInner(
     const SceneContent* content,
     const Snapshot* snapshot,
     const SkPoint& local_point,
     const SkMatrix44& global_to_local_transform,
     mojo::Array<mojo::gfx::composition::HitPtr>* hits) const {
   DCHECK(content);
   DCHECK(snapshot);
   DCHECK(hits);
 
   // TODO(jeffbrown): Implement a more efficient way to traverse children in
   // reverse order.
-  std::vector<const NodeDef*> children;
+  std::vector<const Node*> children;
   TraverseSnapshottedChildren(
-      content, snapshot, [this, &children](const NodeDef* child_node) -> bool {
+      content, snapshot, [this, &children](const Node* child_node) -> bool {
         children.push_back(child_node);
         return true;
       });
 
   for (auto it = children.crbegin(); it != children.crend(); ++it) {
     if ((*it)->HitTest(content, snapshot, local_point,
                        global_to_local_transform, hits))
       return true;  // opaque child covering siblings
   }
   return false;
 }
 
-bool NodeDef::HitTestSelf(
+bool Node::HitTestSelf(
     const SceneContent* content,
     const Snapshot* snapshot,
     const SkPoint& local_point,
     const SkMatrix44& global_to_local_transform,
     mojo::Array<mojo::gfx::composition::HitPtr>* hits) const {
   DCHECK(content);
   DCHECK(snapshot);
   DCHECK(hits);
 
   if (!hit_test_behavior_ ||
       hit_test_behavior_->visibility ==
           mojo::gfx::composition::HitTestBehavior::Visibility::INVISIBLE)
     return false;
 
   if (hit_test_behavior_->hit_rect &&
       !Contains(hit_test_behavior_->hit_rect->To<SkRect>(), local_point))
     return false;
 
   auto hit = mojo::gfx::composition::Hit::New();
   hit->set_node(mojo::gfx::composition::NodeHit::New());
   hit->get_node()->node_id = node_id_;
   hit->get_node()->transform =
       mojo::ConvertTo<mojo::TransformPtr>(global_to_local_transform);
   hits->push_back(hit.Pass());
   return hit_test_behavior_->visibility ==
          mojo::gfx::composition::HitTestBehavior::Visibility::OPAQUE;
 }
 
-RectNodeDef::RectNodeDef(
-    uint32_t node_id,
-    std::unique_ptr<TransformPair> content_transform,
-    mojo::RectFPtr content_clip,
-    mojo::gfx::composition::HitTestBehaviorPtr hit_test_behavior,
-    Combinator combinator,
-    const std::vector<uint32_t>& child_node_ids,
-    const mojo::RectF& content_rect,
-    const mojo::gfx::composition::Color& color)
-    : NodeDef(node_id,
-              std::move(content_transform),
-              content_clip.Pass(),
-              hit_test_behavior.Pass(),
-              combinator,
-              child_node_ids),
+RectNode::RectNode(uint32_t node_id,
+                   std::unique_ptr<TransformPair> content_transform,
+                   mojo::RectFPtr content_clip,
+                   mojo::gfx::composition::HitTestBehaviorPtr hit_test_behavior,
+                   Combinator combinator,
+                   const std::vector<uint32_t>& child_node_ids,
+                   const mojo::RectF& content_rect,
+                   const mojo::gfx::composition::Color& color)
+    : Node(node_id,
+           std::move(content_transform),
+           content_clip.Pass(),
+           hit_test_behavior.Pass(),
+           combinator,
+           child_node_ids),
       content_rect_(content_rect),
       color_(color) {}
 
-RectNodeDef::~RectNodeDef() {}
+RectNode::~RectNode() {}
 
-void RectNodeDef::RecordPictureInner(const SceneContent* content,
-                                     const Snapshot* snapshot,
-                                     SkCanvas* canvas) const {
+void RectNode::RecordPictureInner(const SceneContent* content,
+                                  const Snapshot* snapshot,
+                                  SkCanvas* canvas) const {
   DCHECK(content);
   DCHECK(snapshot);
   DCHECK(canvas);
 
   SkPaint paint;
   paint.setColor(MakeSkColor(color_));
   canvas->drawRect(content_rect_.To<SkRect>(), paint);
 
-  NodeDef::RecordPictureInner(content, snapshot, canvas);
+  Node::RecordPictureInner(content, snapshot, canvas);
 }
 
-ImageNodeDef::ImageNodeDef(
+ImageNode::ImageNode(
     uint32_t node_id,
     std::unique_ptr<TransformPair> content_transform,
     mojo::RectFPtr content_clip,
     mojo::gfx::composition::HitTestBehaviorPtr hit_test_behavior,
     Combinator combinator,
     const std::vector<uint32_t>& child_node_ids,
     const mojo::RectF& content_rect,
     mojo::RectFPtr image_rect,
     uint32 image_resource_id,
     mojo::gfx::composition::BlendPtr blend)
-    : NodeDef(node_id,
-              std::move(content_transform),
-              content_clip.Pass(),
-              hit_test_behavior.Pass(),
-              combinator,
-              child_node_ids),
+    : Node(node_id,
+           std::move(content_transform),
+           content_clip.Pass(),
+           hit_test_behavior.Pass(),
+           combinator,
+           child_node_ids),
       content_rect_(content_rect),
       image_rect_(image_rect.Pass()),
       image_resource_id_(image_resource_id),
       blend_(blend.Pass()) {}
 
-ImageNodeDef::~ImageNodeDef() {}
+ImageNode::~ImageNode() {}
 
-bool ImageNodeDef::RecordContent(SceneContentBuilder* builder) const {
+bool ImageNode::RecordContent(SceneContentBuilder* builder) const {
   DCHECK(builder);
 
-  return NodeDef::RecordContent(builder) &&
-         builder->RequireResource(image_resource_id_, ResourceDef::Type::kImage,
+  return Node::RecordContent(builder) &&
+         builder->RequireResource(image_resource_id_, Resource::Type::kImage,
                                   node_id());
 }
 
-void ImageNodeDef::RecordPictureInner(const SceneContent* content,
-                                      const Snapshot* snapshot,
-                                      SkCanvas* canvas) const {
+void ImageNode::RecordPictureInner(const SceneContent* content,
+                                   const Snapshot* snapshot,
+                                   SkCanvas* canvas) const {
   DCHECK(content);
   DCHECK(snapshot);
   DCHECK(canvas);
 
-  auto image_resource = static_cast<const ImageResourceDef*>(
-      content->GetResource(image_resource_id_, ResourceDef::Type::kImage));
+  auto image_resource = static_cast<const ImageResource*>(
+      content->GetResource(image_resource_id_, Resource::Type::kImage));
   DCHECK(image_resource);
 
   SkPaint paint;
   SetPaintForBlend(&paint, blend_.get());
 
   canvas->drawImageRect(image_resource->image()->image().get(),
                         image_rect_
                             ? image_rect_->To<SkRect>()
                             : SkRect::MakeWH(image_resource->image()->width(),
                                              image_resource->image()->height()),
                         content_rect_.To<SkRect>(), &paint);
 
-  NodeDef::RecordPictureInner(content, snapshot, canvas);
+  Node::RecordPictureInner(content, snapshot, canvas);
 }
 
-SceneNodeDef::SceneNodeDef(
+SceneNode::SceneNode(
     uint32_t node_id,
     std::unique_ptr<TransformPair> content_transform,
     mojo::RectFPtr content_clip,
     mojo::gfx::composition::HitTestBehaviorPtr hit_test_behavior,
     Combinator combinator,
     const std::vector<uint32_t>& child_node_ids,
     uint32_t scene_resource_id,
     uint32_t scene_version)
-    : NodeDef(node_id,
-              std::move(content_transform),
-              content_clip.Pass(),
-              hit_test_behavior.Pass(),
-              combinator,
-              child_node_ids),
+    : Node(node_id,
+           std::move(content_transform),
+           content_clip.Pass(),
+           hit_test_behavior.Pass(),
+           combinator,
+           child_node_ids),
       scene_resource_id_(scene_resource_id),
       scene_version_(scene_version) {}
 
-SceneNodeDef::~SceneNodeDef() {}
+SceneNode::~SceneNode() {}
 
-bool SceneNodeDef::RecordContent(SceneContentBuilder* builder) const {
+bool SceneNode::RecordContent(SceneContentBuilder* builder) const {
   DCHECK(builder);
 
-  return NodeDef::RecordContent(builder) &&
-         builder->RequireResource(scene_resource_id_, ResourceDef::Type::kScene,
+  return Node::RecordContent(builder) &&
+         builder->RequireResource(scene_resource_id_, Resource::Type::kScene,
                                   node_id());
 }
 
-Snapshot::Disposition SceneNodeDef::RecordSnapshot(
+Snapshot::Disposition SceneNode::RecordSnapshot(
     const SceneContent* content,
     SnapshotBuilder* builder) const {
   DCHECK(content);
   DCHECK(builder);
 
-  auto scene_resource = static_cast<const SceneResourceDef*>(
-      content->GetResource(scene_resource_id_, ResourceDef::Type::kScene));
+  auto scene_resource = static_cast<const SceneResource*>(
+      content->GetResource(scene_resource_id_, Resource::Type::kScene));
   DCHECK(scene_resource);
 
   SceneDef* referenced_scene = scene_resource->referenced_scene().get();
   if (!referenced_scene) {
     if (builder->block_log()) {
       *builder->block_log()
           << "Scene node blocked because its referenced scene is unavailable: "
           << FormattedLabel(content) << std::endl;
     }
     return Snapshot::Disposition::kBlocked;
   }
 
   Snapshot::Disposition disposition =
       builder->SnapshotScene(referenced_scene, scene_version_, this, content);
   if (disposition != Snapshot::Disposition::kSuccess)
     return disposition;
-  return NodeDef::RecordSnapshot(content, builder);
+  return Node::RecordSnapshot(content, builder);
 }
 
-void SceneNodeDef::RecordPictureInner(const SceneContent* content,
-                                      const Snapshot* snapshot,
-                                      SkCanvas* canvas) const {
+void SceneNode::RecordPictureInner(const SceneContent* content,
+                                   const Snapshot* snapshot,
+                                   SkCanvas* canvas) const {
   DCHECK(content);
   DCHECK(snapshot);
   DCHECK(canvas);
 
   const SceneContent* resolved_content =
       snapshot->GetResolvedSceneContent(this);
   DCHECK(resolved_content);
   resolved_content->RecordPicture(snapshot, canvas);
 
-  NodeDef::RecordPictureInner(content, snapshot, canvas);
+  Node::RecordPictureInner(content, snapshot, canvas);
 }
 
-bool SceneNodeDef::HitTestInner(
+bool SceneNode::HitTestInner(
     const SceneContent* content,
     const Snapshot* snapshot,
     const SkPoint& local_point,
     const SkMatrix44& global_to_local_transform,
     mojo::Array<mojo::gfx::composition::HitPtr>* hits) const {
   DCHECK(content);
   DCHECK(snapshot);
   DCHECK(hits);
 
-  if (NodeDef::HitTestInner(content, snapshot, local_point,
-                            global_to_local_transform, hits))
+  if (Node::HitTestInner(content, snapshot, local_point,
+                         global_to_local_transform, hits))
     return true;  // opaque child covering referenced scene
 
   const SceneContent* resolved_content =
       snapshot->GetResolvedSceneContent(this);
   DCHECK(resolved_content);
 
   mojo::gfx::composition::SceneHitPtr scene_hit;
   bool opaque = resolved_content->HitTest(
       snapshot, local_point, global_to_local_transform, &scene_hit);
   if (scene_hit) {
     auto hit = mojo::gfx::composition::Hit::New();
     hit->set_scene(scene_hit.Pass());
     hits->push_back(hit.Pass());
   }
   return opaque;
 }
 
-LayerNodeDef::LayerNodeDef(
+LayerNode::LayerNode(
     uint32_t node_id,
     std::unique_ptr<TransformPair> content_transform,
     mojo::RectFPtr content_clip,
     mojo::gfx::composition::HitTestBehaviorPtr hit_test_behavior,
     Combinator combinator,
     const std::vector<uint32_t>& child_node_ids,
     const mojo::RectF& layer_rect,
     mojo::gfx::composition::BlendPtr blend)
-    : NodeDef(node_id,
-              std::move(content_transform),
-              content_clip.Pass(),
-              hit_test_behavior.Pass(),
-              combinator,
-              child_node_ids),
+    : Node(node_id,
+           std::move(content_transform),
+           content_clip.Pass(),
+           hit_test_behavior.Pass(),
+           combinator,
+           child_node_ids),
       layer_rect_(layer_rect),
       blend_(blend.Pass()) {}
 
-LayerNodeDef::~LayerNodeDef() {}
+LayerNode::~LayerNode() {}
 
-void LayerNodeDef::RecordPictureInner(const SceneContent* content,
-                                      const Snapshot* snapshot,
-                                      SkCanvas* canvas) const {
+void LayerNode::RecordPictureInner(const SceneContent* content,
+                                   const Snapshot* snapshot,
+                                   SkCanvas* canvas) const {
   DCHECK(content);
   DCHECK(snapshot);
   DCHECK(canvas);
 
   SkPaint paint;
   SetPaintForBlend(&paint, blend_.get());
 
   canvas->saveLayer(layer_rect_.To<SkRect>(), &paint);
-  NodeDef::RecordPictureInner(content, snapshot, canvas);
+  Node::RecordPictureInner(content, snapshot, canvas);
   canvas->restore();
 }
 
 }  // namespace compositor