Removes usage of aura::Window from Node

mojo/services/view_manager/view_manager_service_impl.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 "mojo/services/view_manager/view_manager_service_impl.h"
 
 #include "base/bind.h"
 #include "mojo/services/public/cpp/geometry/geometry_type_converters.h"
 #include "mojo/services/public/cpp/input_events/input_events_type_converters.h"
 #include "mojo/services/view_manager/default_access_policy.h"
@@ skipping 139 matching lines @@
 bool ViewManagerServiceImpl::IsNodeKnown(const Node* node) const {
   return known_nodes_.count(NodeIdToTransportId(node->id())) > 0;
 }
 
 bool ViewManagerServiceImpl::CanReorderNode(const Node* node,
                                             const Node* relative_node,
                                             OrderDirection direction) const {
   if (!node || !relative_node)
     return false;
 
-  const Node* parent = node->GetParent();
-  if (!parent || parent != relative_node->GetParent())
+  if (!node->parent() || node->parent() != relative_node->parent())
     return false;
 
   if (!access_policy_->CanReorderNode(node, relative_node, direction))
     return false;
 
-  std::vector<const Node*> children = parent->GetChildren();
+  std::vector<const Node*> children = node->parent()->GetChildren();
   const size_t child_i =
       std::find(children.begin(), children.end(), node) - children.begin();
   const size_t target_i =
       std::find(children.begin(), children.end(), relative_node) -
       children.begin();
   if ((direction == ORDER_DIRECTION_ABOVE && child_i == target_i + 1) ||
       (direction == ORDER_DIRECTION_BELOW && child_i + 1 == target_i)) {
     return false;
   }
 
@@ skipping 71 matching lines @@
     return;
 
   client()->OnViewDeleted(transport_node_id);
   root_node_manager_->OnConnectionMessagedClient(id_);
 
   // This connection no longer knows about the node. Unparent any nodes that
   // were parented to nodes in the root.
   std::vector<Node*> local_nodes;
   RemoveFromKnown(GetNode(node_id), &local_nodes);
   for (size_t i = 0; i < local_nodes.size(); ++i)
-    local_nodes[i]->GetParent()->Remove(local_nodes[i]);
+    local_nodes[i]->parent()->Remove(local_nodes[i]);
 }
 
 void ViewManagerServiceImpl::RemoveChildrenAsPartOfEmbed(
     const NodeId& node_id) {
   Node* node = GetNode(node_id);
   CHECK(node);
   CHECK(node->id().connection_id == node_id.connection_id);
   std::vector<Node*> children = node->GetChildren();
   for (size_t i = 0; i < children.size(); ++i)
     node->Remove(children[i]);
 }
 
 Array<ViewDataPtr> ViewManagerServiceImpl::NodesToViewDatas(
     const std::vector<const Node*>& nodes) {
   Array<ViewDataPtr> array(nodes.size());
   for (size_t i = 0; i < nodes.size(); ++i)
     array[i] = NodeToViewData(nodes[i]).Pass();
   return array.Pass();
 }
 
 ViewDataPtr ViewManagerServiceImpl::NodeToViewData(const Node* node) {
   DCHECK(IsNodeKnown(node));
-  const Node* parent = node->GetParent();
+  const Node* parent = node->parent();
   // If the parent isn't known, it means the parent is not visible to us (not
   // in roots), and should not be sent over.
   if (parent && !IsNodeKnown(parent))
     parent = NULL;
   ViewDataPtr view_data(ViewData::New());
   view_data->parent_id = NodeIdToTransportId(parent ? parent->id() : NodeId());
   view_data->view_id = NodeIdToTransportId(node->id());
   view_data->bounds = Rect::From(node->bounds());
   return view_data.Pass();
 }
@@ skipping 45 matching lines @@
   callback.Run(success);
 }
 
 void ViewManagerServiceImpl::AddView(
     Id parent_id,
     Id child_id,
     const Callback<void(bool)>& callback) {
   bool success = false;
   Node* parent = GetNode(NodeIdFromTransportId(parent_id));
   Node* child = GetNode(NodeIdFromTransportId(child_id));
-  if (parent && child && child->GetParent() != parent &&
+  if (parent && child && child->parent() != parent &&
       !child->Contains(parent) && access_policy_->CanAddNode(parent, child)) {
     success = true;
     RootNodeManager::ScopedChange change(this, root_node_manager_, false);
     parent->Add(child);
   }
   callback.Run(success);
 }
 
 void ViewManagerServiceImpl::RemoveViewFromParent(
     Id view_id,
     const Callback<void(bool)>& callback) {
   bool success = false;
   Node* node = GetNode(NodeIdFromTransportId(view_id));
-  if (node && node->GetParent() &&
+  if (node && node->parent() &&
       access_policy_->CanRemoveNodeFromParent(node)) {
     success = true;
     RootNodeManager::ScopedChange change(this, root_node_manager_, false);
-    node->GetParent()->Remove(node);
+    node->parent()->Remove(node);
   }
   callback.Run(success);
 }
 
 void ViewManagerServiceImpl::ReorderView(Id view_id,
                                          Id relative_view_id,
                                          OrderDirection direction,
                                          const Callback<void(bool)>& callback) {
   bool success = false;
   Node* node = GetNode(NodeIdFromTransportId(view_id));
   Node* relative_node = GetNode(NodeIdFromTransportId(relative_view_id));
   if (CanReorderNode(node, relative_node, direction)) {
     success = true;
     RootNodeManager::ScopedChange change(this, root_node_manager_, false);
-    node->GetParent()->Reorder(node, relative_node, direction);
+    node->parent()->Reorder(node, relative_node, direction);
     root_node_manager_->ProcessNodeReorder(node, relative_node, direction);
   }
   callback.Run(success);
 }
 
 void ViewManagerServiceImpl::GetViewTree(
     Id view_id,
     const Callback<void(Array<ViewDataPtr>)>& callback) {
   Node* node = GetNode(NodeIdFromTransportId(view_id));
   std::vector<const Node*> nodes;
@@ skipping 30 matching lines @@
 }
 
 void ViewManagerServiceImpl::SetViewBounds(
     Id view_id,
     RectPtr bounds,
     const Callback<void(bool)>& callback) {
   Node* node = GetNode(NodeIdFromTransportId(view_id));
   const bool success = node && access_policy_->CanSetNodeBounds(node);
   if (success) {
     RootNodeManager::ScopedChange change(this, root_node_manager_, false);
-    gfx::Rect old_bounds = node->window()->bounds();
-    node->window()->SetBounds(bounds.To<gfx::Rect>());
+    node->SetBounds(bounds.To<gfx::Rect>());
   }
   callback.Run(success);
 }
 
 void ViewManagerServiceImpl::SetViewVisibility(
     Id transport_view_id,
     bool visible,
     const Callback<void(bool)>& callback) {
   Node* node = GetNode(NodeIdFromTransportId(transport_view_id));
-  const bool success = node && node->IsVisible() != visible &&
+  const bool success = node && node->visible() != visible &&
       access_policy_->CanChangeNodeVisibility(node);
   if (success) {
     DCHECK(node);
     node->SetVisible(visible);
   }
   // TODO(sky): need to notify of visibility changes.
   callback.Run(success);
 }
 
 void ViewManagerServiceImpl::Embed(
@@ skipping 85 matching lines @@
 
 bool ViewManagerServiceImpl::IsNodeRootOfAnotherConnectionForAccessPolicy(
     const Node* node) const {
   ViewManagerServiceImpl* connection =
       root_node_manager_->GetConnectionWithRoot(node->id());
   return connection && connection != this;
 }
 
 }  // namespace service
 }  // namespace mojo