Mozart: Rename scene graph classes.

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"
@@ skipping 89 matching lines @@
 
   // Update resources.
   if (update->clear_resources) {
     resources_.clear();
   }
   for (auto it = update->resources.begin(); it != update->resources.end();
        ++it) {
     uint32_t resource_id = it.GetKey();
     mojo::gfx::composition::ResourcePtr& resource_decl = it.GetValue();
     if (resource_decl) {
-      scoped_refptr<const ResourceDef> resource = CreateResource(
+      scoped_refptr<const Resource> resource = CreateResource(
           resource_id, resource_decl.Pass(), resolver, unavailable_sender, err);
       if (!resource)
         return false;
       resources_[resource_id] = std::move(resource);
     } else {
       resources_.erase(resource_id);
     }
   }
 
   // Update nodes.
   if (update->clear_nodes) {
     nodes_.clear();
   }
   for (auto it = update->nodes.begin(); it != update->nodes.end(); ++it) {
     uint32_t node_id = it.GetKey();
     mojo::gfx::composition::NodePtr& node_decl = it.GetValue();
     if (node_decl) {
-      scoped_refptr<const NodeDef> node =
+      scoped_refptr<const Node> node =
           CreateNode(node_id, node_decl.Pass(), err);
       if (!node)
         return false;
       nodes_[node_id] = std::move(node);
     } else {
       nodes_.erase(node_id);
     }
   }
   return true;
 }
 
 bool SceneDef::UnlinkReferencedScene(
     SceneDef* scene,
     const SceneUnavailableSender& unavailable_sender) {
   DCHECK(scene);
 
   bool changed = false;
   for (auto& pair : resources_) {
-    if (pair.second->type() == ResourceDef::Type::kScene) {
+    if (pair.second->type() == Resource::Type::kScene) {
       auto scene_resource =
-          static_cast<const SceneResourceDef*>(pair.second.get());
+          static_cast<const SceneResource*>(pair.second.get());
       if (scene_resource->referenced_scene().get() == scene) {
         changed = true;
         pair.second = scene_resource->Unlink();
         unavailable_sender.Run(pair.first);
       }
     }
   }
   return changed;
 }
 
-scoped_refptr<const ResourceDef> SceneDef::CreateResource(
+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)
       unavailable_sender.Run(resource_id);
-    return new SceneResourceDef(scene_token, referenced_scene);
+    return new SceneResource(scene_token, referenced_scene);
   }
 
   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 15 matching lines @@
         base::MessageLoop::current()->task_runner(),
         base::Bind(
             &ReleaseMailboxTexture,
             base::Passed(
                 mojo::gfx::composition::MailboxTextureCallbackPtr::Create(
                     std::move(mailbox_texture_resource_decl->callback)))));
     if (!image) {
       err << "Could not create MailboxTexture";
       return nullptr;
     }
-    return new ImageResourceDef(image);
+    return new ImageResource(image);
   }
 
   err << "Unsupported resource type: resource_id=" << resource_id;
   return nullptr;
 }
 
-scoped_refptr<const NodeDef> SceneDef::CreateNode(
+scoped_refptr<const Node> SceneDef::CreateNode(
     uint32_t node_id,
     mojo::gfx::composition::NodePtr node_decl,
     std::ostream& err) {
   DCHECK(node_decl);
 
   std::unique_ptr<TransformPair> content_transform;
   if (node_decl->content_transform) {
     content_transform.reset(
         new TransformPair(node_decl->content_transform.To<SkMatrix44>()));
   }
   mojo::RectFPtr content_clip = node_decl->content_clip.Pass();
   mojo::gfx::composition::HitTestBehaviorPtr hit_test_behavior =
       node_decl->hit_test_behavior.Pass();
   const mojo::gfx::composition::Node::Combinator combinator =
       node_decl->combinator;
   const std::vector<uint32_t>& child_node_ids =
       node_decl->child_node_ids.storage();
 
   if (!node_decl->op) {
-    return new NodeDef(node_id, std::move(content_transform),
-                       content_clip.Pass(), hit_test_behavior.Pass(),
-                       combinator, child_node_ids);
+    return new Node(node_id, std::move(content_transform), content_clip.Pass(),
+                    hit_test_behavior.Pass(), combinator, child_node_ids);
   }
 
   if (node_decl->op->is_rect()) {
     auto& rect_node_decl = node_decl->op->get_rect();
     DCHECK(rect_node_decl->content_rect);
     DCHECK(rect_node_decl->color);
 
     const mojo::RectF& content_rect = *rect_node_decl->content_rect;
     const mojo::gfx::composition::Color& color = *rect_node_decl->color;
-    return new RectNodeDef(node_id, std::move(content_transform),
-                           content_clip.Pass(), hit_test_behavior.Pass(),
-                           combinator, child_node_ids, content_rect, color);
+    return new RectNode(node_id, std::move(content_transform),
+                        content_clip.Pass(), hit_test_behavior.Pass(),
+                        combinator, child_node_ids, content_rect, color);
   }
 
   if (node_decl->op->is_image()) {
     auto& image_node_decl = node_decl->op->get_image();
     DCHECK(image_node_decl->content_rect);
 
     const mojo::RectF& content_rect = *image_node_decl->content_rect;
     mojo::RectFPtr image_rect = image_node_decl->image_rect.Pass();
     const uint32 image_resource_id = image_node_decl->image_resource_id;
     mojo::gfx::composition::BlendPtr blend = image_node_decl->blend.Pass();
-    return new ImageNodeDef(node_id, std::move(content_transform),
-                            content_clip.Pass(), hit_test_behavior.Pass(),
-                            combinator, child_node_ids, content_rect,
-                            image_rect.Pass(), image_resource_id, blend.Pass());
+    return new ImageNode(node_id, std::move(content_transform),
+                         content_clip.Pass(), hit_test_behavior.Pass(),
+                         combinator, child_node_ids, content_rect,
+                         image_rect.Pass(), image_resource_id, blend.Pass());
   }
 
   if (node_decl->op->is_scene()) {
     auto& scene_node_decl = node_decl->op->get_scene();
 
     const uint32_t scene_resource_id = scene_node_decl->scene_resource_id;
     const uint32_t scene_version = scene_node_decl->scene_version;
-    return new SceneNodeDef(node_id, std::move(content_transform),
-                            content_clip.Pass(), hit_test_behavior.Pass(),
-                            combinator, child_node_ids, scene_resource_id,
-                            scene_version);
+    return new SceneNode(node_id, std::move(content_transform),
+                         content_clip.Pass(), hit_test_behavior.Pass(),
+                         combinator, child_node_ids, scene_resource_id,
+                         scene_version);
   }
 
   if (node_decl->op->is_layer()) {
     auto& layer_node_decl = node_decl->op->get_layer();
     DCHECK(layer_node_decl->layer_rect);
 
     const mojo::RectF& layer_rect = *layer_node_decl->layer_rect;
     mojo::gfx::composition::BlendPtr blend = layer_node_decl->blend.Pass();
-    return new LayerNodeDef(node_id, std::move(content_transform),
-                            content_clip.Pass(), hit_test_behavior.Pass(),
-                            combinator, child_node_ids, layer_rect,
-                            blend.Pass());
+    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 NodeDef* SceneDef::FindNode(uint32_t node_id) const {
+const Node* SceneDef::FindNode(uint32_t node_id) const {
   auto it = nodes_.find(node_id);
   return it != nodes_.end() ? it->second.get() : nullptr;
 }
 
-const ResourceDef* SceneDef::FindResource(uint32_t resource_id) const {
+const Resource* SceneDef::FindResource(uint32_t resource_id) const {
   auto it = resources_.find(resource_id);
   return it != resources_.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();
 }
 
 SceneDef::Publication::Publication(
     mojo::gfx::composition::SceneMetadataPtr metadata)
     : metadata(metadata.Pass()) {
   DCHECK(this->metadata);
 }
 
 SceneDef::Publication::~Publication() {}
 
 }  // namespace compositor