Rename Node to View in the View Manager mojom & client lib. Service TBD.

mojo/services/view_manager/view_manager_unittest.cc

 // Copyright 2014 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 <string>
 #include <vector>
 
 #include "base/at_exit.h"
 #include "base/auto_reset.h"
 #include "base/bind.h"
@@ skipping 90 matching lines @@
     std::vector<Change> changes;
     tracker_->changes()->swap(changes);
     changes_.swap(changes);
   }
 
   // The following functions are cover methods for ViewManagerService. They
   // block until the result is received.
   bool CreateNode(Id node_id) {
     changes_.clear();
     ErrorCode result = ERROR_CODE_NONE;
-    view_manager_->CreateNode(
+    view_manager_->CreateView(
         node_id,
         base::Bind(&ViewManagerProxy::GotResultWithErrorCode,
                    base::Unretained(this), &result));
     RunMainLoop();
     return result == ERROR_CODE_NONE;
   }
   ErrorCode CreateNodeWithErrorCode(Id node_id) {
     changes_.clear();
     ErrorCode result = ERROR_CODE_NONE;
-    view_manager_->CreateNode(
+    view_manager_->CreateView(
         node_id,
         base::Bind(&ViewManagerProxy::GotResultWithErrorCode,
                    base::Unretained(this), &result));
     RunMainLoop();
     return result;
   }
   bool AddNode(Id parent, Id child) {
     changes_.clear();
     bool result = false;
-    view_manager_->AddNode(parent, child,
+    view_manager_->AddView(parent, child,
                            base::Bind(&ViewManagerProxy::GotResult,
                                       base::Unretained(this), &result));
     RunMainLoop();
     return result;
   }
   bool RemoveNodeFromParent(Id node_id) {
     changes_.clear();
     bool result = false;
-    view_manager_->RemoveNodeFromParent(node_id,
+    view_manager_->RemoveViewFromParent(node_id,
         base::Bind(&ViewManagerProxy::GotResult,
                    base::Unretained(this), &result));
     RunMainLoop();
     return result;
   }
   bool ReorderNode(Id node_id,
                    Id relative_node_id,
                    OrderDirection direction) {
     changes_.clear();
     bool result = false;
-    view_manager_->ReorderNode(node_id, relative_node_id, direction,
+    view_manager_->ReorderView(node_id, relative_node_id, direction,
                                base::Bind(&ViewManagerProxy::GotResult,
                                           base::Unretained(this), &result));
     RunMainLoop();
     return result;
   }
   void GetNodeTree(Id node_id, std::vector<TestNode>* nodes) {
     changes_.clear();
-    view_manager_->GetNodeTree(node_id,
+    view_manager_->GetViewTree(node_id,
                                base::Bind(&ViewManagerProxy::GotNodeTree,
                                           base::Unretained(this), nodes));
     RunMainLoop();
   }
   bool Embed(const Id node_id, const char* url) {
     changes_.clear();
     base::AutoReset<bool> auto_reset(&in_embed_, true);
     bool result = false;
     ServiceProviderPtr services;
     view_manager_->Embed(url, node_id, services.Pass(),
                          base::Bind(&ViewManagerProxy::GotResult,
                                     base::Unretained(this), &result));
     RunMainLoop();
     return result;
   }
   bool DeleteNode(Id node_id) {
     changes_.clear();
     bool result = false;
-    view_manager_->DeleteNode(node_id,
+    view_manager_->DeleteView(node_id,
                               base::Bind(&ViewManagerProxy::GotResult,
                                          base::Unretained(this), &result));
     RunMainLoop();
     return result;
   }
   bool SetNodeBounds(Id node_id, const gfx::Rect& bounds) {
     changes_.clear();
     bool result = false;
-    view_manager_->SetNodeBounds(node_id, Rect::From(bounds),
+    view_manager_->SetViewBounds(node_id, Rect::From(bounds),
                                  base::Bind(&ViewManagerProxy::GotResult,
                                             base::Unretained(this), &result));
     RunMainLoop();
     return result;
   }
 
  private:
   friend class TestViewManagerClientConnection;
 
   void set_router(mojo::internal::Router* router) { router_ = router; }
@@ skipping 33 matching lines @@
     main_run_loop_->Quit();
   }
 
   void GotResultWithErrorCode(ErrorCode* error_code_cache,
                               ErrorCode error_code) {
     *error_code_cache = error_code;
     DCHECK(main_run_loop_);
     main_run_loop_->Quit();
   }
 
-  void GotNodeTree(std::vector<TestNode>* nodes, Array<NodeDataPtr> results) {
-    NodeDatasToTestNodes(results, nodes);
+  void GotNodeTree(std::vector<TestNode>* nodes, Array<ViewDataPtr> results) {
+    ViewDatasToTestNodes(results, nodes);
     DCHECK(main_run_loop_);
     main_run_loop_->Quit();
   }
 
   // TestChangeTracker::Delegate:
   virtual void OnChangeAdded() OVERRIDE {
     if (quit_count_ > 0 && --quit_count_ == 0)
       QuitCountReached();
   }
 
@@ skipping 37 matching lines @@
   // InterfaceImpl:
   virtual void OnConnectionEstablished() OVERRIDE {
     connection_.set_router(internal_state()->router());
     connection_.set_view_manager(client());
   }
 
   // ViewManagerClient:
   virtual void OnEmbed(
       ConnectionSpecificId connection_id,
       const String& creator_url,
-      NodeDataPtr root,
+      ViewDataPtr root,
       InterfaceRequest<ServiceProvider> services) OVERRIDE {
     tracker_.OnEmbed(connection_id, creator_url, root.Pass());
   }
-  virtual void OnNodeBoundsChanged(Id node_id,
+  virtual void OnViewBoundsChanged(Id node_id,
                                    RectPtr old_bounds,
                                    RectPtr new_bounds) OVERRIDE {
     tracker_.OnNodeBoundsChanged(node_id, old_bounds.Pass(), new_bounds.Pass());
   }
-  virtual void OnNodeHierarchyChanged(Id node,
+  virtual void OnViewHierarchyChanged(Id node,
                                       Id new_parent,
                                       Id old_parent,
-                                      Array<NodeDataPtr> nodes) OVERRIDE {
+                                      Array<ViewDataPtr> nodes) OVERRIDE {
     tracker_.OnNodeHierarchyChanged(node, new_parent, old_parent, nodes.Pass());
   }
-  virtual void OnNodeReordered(Id node_id,
+  virtual void OnViewReordered(Id node_id,
                                Id relative_node_id,
                                OrderDirection direction) OVERRIDE {
     tracker_.OnNodeReordered(node_id, relative_node_id, direction);
   }
-  virtual void OnNodeDeleted(Id node) OVERRIDE {
+  virtual void OnViewDeleted(Id node) OVERRIDE {
     tracker_.OnNodeDeleted(node);
   }
-  virtual void OnNodeInputEvent(Id node_id,
+  virtual void OnViewInputEvent(Id node_id,
                                 EventPtr event,
                                 const Callback<void()>& callback) OVERRIDE {
     tracker_.OnNodeInputEvent(node_id, event.Pass());
   }
   virtual void OnFocusChanged(Id gained_focus_id,
                               Id lost_focus_id) OVERRIDE {}
   virtual void Embed(
       const String& url,
       InterfaceRequest<ServiceProvider> service_provider) OVERRIDE {
     tracker_.DelegateEmbed(url);
   }
-  virtual void DispatchOnNodeInputEvent(Id node_id,
+  virtual void DispatchOnViewInputEvent(Id node_id,
                                         mojo::EventPtr event) OVERRIDE {
   }
 
  private:
   TestChangeTracker tracker_;
   ViewManagerProxy connection_;
 
   DISALLOW_COPY_AND_ASSIGN(TestViewManagerClientConnection);
 };
 
@@ skipping 825 matching lines @@
 }
 
 TEST_F(ViewManagerTest, OnNodeInput) {
   ASSERT_TRUE(connection_->CreateNode(BuildNodeId(1, 1)));
   ASSERT_NO_FATAL_FAILURE(EstablishSecondConnection(false));
 
   // Dispatch an event to the node and verify its received.
   {
     EventPtr event(Event::New());
     event->action = static_cast<EventType>(1);
-    connection_->view_manager()->DispatchOnNodeInputEvent(
+    connection_->view_manager()->DispatchOnViewInputEvent(
         BuildNodeId(1, 1),
         event.Pass());
     connection2_->DoRunLoopUntilChangesCount(1);
     const Changes changes(ChangesToDescription1(connection2_->changes()));
     ASSERT_EQ(1u, changes.size());
     EXPECT_EQ("InputEvent node=1,1 event_action=1", changes[0]);
   }
 }
 
 TEST_F(ViewManagerTest, EmbedWithSameNodeId) {
@@ skipping 92 matching lines @@
 // that SetBounsdNodes/AddNode and the like don't result in messages to the
 // originating connection.
 
 // TODO(beng): Add tests for focus:
 // - focus between two nodes known to a connection
 // - focus between nodes unknown to one of the connections.
 // - focus between nodes unknown to either connection.
 
 }  // namespace service
 }  // namespace mojo