Mojo: more idiomatic C++ bindings

mojo/services/view_manager/view_manager_connection.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_connection.h"
 
 #include "base/stl_util.h"
-#include "mojo/public/cpp/bindings/allocation_scope.h"
 #include "mojo/services/view_manager/node.h"
 #include "mojo/services/view_manager/root_node_manager.h"
 #include "mojo/services/view_manager/type_converters.h"
 #include "mojo/services/view_manager/view.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "ui/aura/window.h"
 #include "ui/gfx/codec/png_codec.h"
 
 namespace mojo {
 namespace view_manager {
@@ skipping 37 matching lines @@
   STLDeleteContainerPairSecondPointers(node_map_.begin(), node_map_.end());
   root_node_manager_->RemoveConnection(this);
 }
 
 void ViewManagerConnection::OnConnectionEstablished() {
   DCHECK_EQ(0, id_);  // Should only get OnConnectionEstablished() once.
   id_ = root_node_manager_->GetAndAdvanceNextConnectionId();
   root_node_manager_->AddConnection(this);
   std::vector<const Node*> to_send;
   GetUnknownNodesFrom(root_node_manager_->root(), &to_send);
-  AllocationScope allocation_scope;
   client()->OnConnectionEstablished(
       id_,
       root_node_manager_->next_server_change_id(),
-      Array<INode>::From(to_send));
+      Array<INodePtr>::From(to_send));
 }
 
 void ViewManagerConnection::OnConnectionError() {}
 
 const Node* ViewManagerConnection::GetNode(const NodeId& id) const {
   if (id_ == id.connection_id) {
     NodeMap::const_iterator i = node_map_.find(id.node_id);
     return i == node_map_.end() ? NULL : i->second;
   }
   return root_node_manager_->GetNode(id);
@@ skipping 16 matching lines @@
   if (originated_change || root_node_manager_->is_processing_delete_node())
     return;
   std::vector<const Node*> to_send;
   if (!ShouldNotifyOnHierarchyChange(node, new_parent, old_parent, &to_send)) {
     if (root_node_manager_->IsProcessingChange()) {
       client()->OnServerChangeIdAdvanced(
           root_node_manager_->next_server_change_id() + 1);
     }
     return;
   }
-  AllocationScope allocation_scope;
   const NodeId new_parent_id(new_parent ? new_parent->id() : NodeId());
   const NodeId old_parent_id(old_parent ? old_parent->id() : NodeId());
   client()->OnNodeHierarchyChanged(NodeIdToTransportId(node->id()),
                                    NodeIdToTransportId(new_parent_id),
                                    NodeIdToTransportId(old_parent_id),
                                    server_change_id,
-                                   Array<INode>::From(to_send));
+                                   Array<INodePtr>::From(to_send));
 }
 
 void ViewManagerConnection::ProcessNodeViewReplaced(
     const Node* node,
     const View* new_view,
     const View* old_view,
     bool originated_change) {
   if (originated_change)
     return;
   const TransportViewId new_view_id = new_view ?
@@ skipping 146 matching lines @@
     callback.Run(false);
     return;
   }
   node_map_[node_id.node_id] = new Node(this, node_id);
   callback.Run(true);
 }
 
 void ViewManagerConnection::DeleteNode(
     TransportNodeId transport_node_id,
     const Callback<void(bool)>& callback) {
-  AllocationScope allocation_scope;
   const NodeId node_id(NodeIdFromTransportId(transport_node_id));
   bool did_delete = CanDeleteNode(node_id);
   if (did_delete) {
     ViewManagerConnection* connection = root_node_manager_->GetConnection(
         node_id.connection_id);
     did_delete = connection && connection->DeleteNodeImpl(this, node_id);
   }
   callback.Run(did_delete);
 }
 
@@ skipping 31 matching lines @@
           this, root_node_manager_,
           RootNodeManager::CHANGE_TYPE_ADVANCE_SERVER_CHANGE_ID, false);
       node->GetParent()->Remove(node);
     }
   }
   callback.Run(success);
 }
 
 void ViewManagerConnection::GetNodeTree(
     TransportNodeId node_id,
-    const Callback<void(Array<INode>)>& callback) {
-  AllocationScope allocation_scope;
+    const Callback<void(Array<INodePtr>)>& callback) {
   Node* node = GetNode(NodeIdFromTransportId(node_id));
   std::vector<const Node*> nodes;
   GetDescendants(node, &nodes);
   for (size_t i = 0; i < nodes.size(); ++i)
     known_nodes_.insert(NodeIdToTransportId(nodes[i]->id()));
-  callback.Run(Array<INode>::From(nodes));
+  callback.Run(Array<INodePtr>::From(nodes));
 }
 
 void ViewManagerConnection::CreateView(
     TransportViewId transport_view_id,
     const Callback<void(bool)>& callback) {
   const ViewId view_id(ViewIdFromTransportId(transport_view_id));
   if (view_id.connection_id != id_ || view_map_.count(view_id.view_id)) {
     callback.Run(false);
     return;
   }
@@ skipping 49 matching lines @@
 
 void ViewManagerConnection::OnNodeViewReplaced(const Node* node,
                                                const View* new_view,
                                                const View* old_view) {
   root_node_manager_->ProcessNodeViewReplaced(node, new_view, old_view);
 }
 
 }  // namespace service
 }  // namespace view_manager
 }  // namespace mojo