Mozart: Rename scene graph classes.

services/gfx/compositor/graph/scene_content.h

 // 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.
 
 #ifndef SERVICES_GFX_COMPOSITOR_GRAPH_SCENE_CONTENT_H_
 #define SERVICES_GFX_COMPOSITOR_GRAPH_SCENE_CONTENT_H_
 
 #include <iosfwd>
 #include <unordered_map>
 
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/weak_ptr.h"
 #include "mojo/services/gfx/composition/interfaces/hit_tests.mojom.h"
 #include "mojo/services/gfx/composition/interfaces/scenes.mojom.h"
-#include "services/gfx/compositor/graph/node_def.h"
-#include "services/gfx/compositor/graph/resource_def.h"
+#include "services/gfx/compositor/graph/nodes.h"
+#include "services/gfx/compositor/graph/resources.h"
 #include "services/gfx/compositor/graph/scene_label.h"
 
 class SkCanvas;
 struct SkPoint;
 class SkMatrix44;
 
 namespace compositor {
 
 class SceneContentBuilder;
 class SceneDef;
@@ skipping 34 matching lines @@
   // The |global_to_scene_transform| is the accumulated transform from the
   // global coordinate space to the scene's coordinate space.
   // Provides hit information for the scene in |out_scene_hit| if any.
   // Returns true if the search was terminated by an opaque hit.
   bool HitTest(const Snapshot* snapshot,
                const SkPoint& scene_point,
                const SkMatrix44& global_to_scene_transform,
                mojo::gfx::composition::SceneHitPtr* out_scene_hit) const;
 
   // Gets the requested resource, never null because it must be present.
-  const ResourceDef* GetResource(uint32_t resource_id,
-                                 ResourceDef::Type resource_type) const;
+  const Resource* GetResource(uint32_t resource_id,
+                              Resource::Type resource_type) const;
 
   // Gets the requested node, never null because it must be present.
-  const NodeDef* GetNode(uint32_t node_id) const;
+  const Node* GetNode(uint32_t node_id) const;
 
   // Gets the root node if it exists, otherwise returns nullptr.
-  const NodeDef* GetRootNodeIfExists() const;
+  const Node* GetRootNodeIfExists() const;
 
  private:
   friend class base::RefCounted<SceneContent>;
   friend class SceneContentBuilder;
   SceneContent(const SceneLabel& label,
                uint32_t version,
                size_t max_resources,
                size_t max_nodes);
   ~SceneContent();
 
   const SceneLabel label_;
   const uint32_t version_;
-  std::unordered_map<uint32_t, scoped_refptr<const ResourceDef>> resources_;
-  std::unordered_map<uint32_t, scoped_refptr<const NodeDef>> nodes_;
+  std::unordered_map<uint32_t, scoped_refptr<const Resource>> resources_;
+  std::unordered_map<uint32_t, scoped_refptr<const Node>> nodes_;
 
   DISALLOW_COPY_AND_ASSIGN(SceneContent);
 };
 
 // Builds a table of all of the nodes and resources that make up the
 // content of a particular version of a scene.
 class SceneContentBuilder {
  public:
   SceneContentBuilder(const SceneDef* scene,
                       uint32_t version,
                       std::ostream& err,
                       size_t max_resources,
                       size_t max_nodes);
   ~SceneContentBuilder();
 
   // Stream for reporting validation error messages.
   std::ostream& err() { return err_; }
 
   // Ensures the requested resource is part of the retained scene graph and
   // returns a reference to it, or nullptr if an error occurred.
-  const ResourceDef* RequireResource(uint32_t resource_id,
-                                     ResourceDef::Type resource_type,
-                                     uint32_t referrer_node_id);
+  const Resource* RequireResource(uint32_t resource_id,
+                                  Resource::Type resource_type,
+                                  uint32_t referrer_node_id);
 
   // Ensures the requested node is part of the retained scene graph and
   // returns a reference to it, or nullptr if an error occurred.
-  const NodeDef* RequireNode(uint32_t node_id, uint32_t referrer_node_id);
+  const Node* RequireNode(uint32_t node_id, uint32_t referrer_node_id);
 
   // Builds the content graph.
   // Returns nullptr if an error occurred.
   scoped_refptr<const SceneContent> Build();
 
  private:
-  bool AddNode(const NodeDef* node);
+  bool AddNode(const Node* node);
 
   scoped_refptr<SceneContent> content_;
   const SceneDef* scene_;
   std::ostream& err_;
 };
 
 }  // namespace compositor
 
 #endif  // SERVICES_GFX_COMPOSITOR_GRAPH_SCENE_CONTENT_H_