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/geometry/geometry_type_converters.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/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 {
 namespace service {
@@ skipping 69 matching lines @@
 
 void ViewManagerConnection::ProcessNodeBoundsChanged(
     const Node* node,
     const gfx::Rect& old_bounds,
     const gfx::Rect& new_bounds,
     bool originated_change) {
   if (originated_change)
     return;
   TransportNodeId node_id = NodeIdToTransportId(node->id());
   if (known_nodes_.count(node_id) > 0) {
-    AllocationScope scope;
-    client()->OnNodeBoundsChanged(node_id, old_bounds, new_bounds);
+    client()->OnNodeBoundsChanged(node_id,
+                                  Rect::From(old_bounds),
+                                  Rect::From(new_bounds));
   }
 }
 
 void ViewManagerConnection::ProcessNodeHierarchyChanged(
     const Node* node,
     const Node* new_parent,
     const Node* old_parent,
     TransportChangeId server_change_id,
     bool originated_change) {
   if (known_nodes_.count(NodeIdToTransportId(node->id())) > 0) {
@@ skipping 13 matching lines @@
     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());
   DCHECK((node->id().connection_id == id_) ||
          (roots_.count(NodeIdToTransportId(node->id())) > 0) ||
          (new_parent && IsNodeDescendantOfRoots(new_parent)) ||
          (old_parent && IsNodeDescendantOfRoots(old_parent)));
   client()->OnNodeHierarchyChanged(NodeIdToTransportId(node->id()),
                                    NodeIdToTransportId(new_parent_id),
                                    NodeIdToTransportId(old_parent_id),
                                    server_change_id,
@@ skipping 258 matching lines @@
     roots.insert(transport_node_ids[i]);
   }
   roots_.swap(roots);
 
   // TODO(sky): remove |known_nodes_.clear()| temporary while this is done here
   // instead of at creation time.
   known_nodes_.clear();
   std::vector<const Node*> to_send;
   for (NodeIdSet::const_iterator i = roots_.begin(); i != roots_.end(); ++i)
     GetUnknownNodesFrom(GetNode(NodeIdFromTransportId(*i)), &to_send);
-  AllocationScope allocation_scope;
   client()->OnViewManagerConnectionEstablished(
       id_,
       root_node_manager_->next_server_change_id(),
       NodesToINodes(to_send));
 
   return true;
 }
 
-Array<INode> ViewManagerConnection::NodesToINodes(
+Array<INodePtr> ViewManagerConnection::NodesToINodes(
     const std::vector<const Node*>& nodes) {
-  Array<INode>::Builder array_builder(nodes.size());
+  Array<INodePtr> array(nodes.size());
   for (size_t i = 0; i < nodes.size(); ++i) {
-    INode::Builder node_builder;
     const Node* node = nodes[i];
     DCHECK(known_nodes_.count(NodeIdToTransportId(node->id())) > 0);
     const Node* parent = node->GetParent();
     // 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 && known_nodes_.count(NodeIdToTransportId(parent->id())) == 0)
       parent = NULL;
-    node_builder.set_parent_id(NodeIdToTransportId(
-                                   parent ? parent->id() : NodeId()));
-    node_builder.set_node_id(NodeIdToTransportId(node->id()));
-    node_builder.set_view_id(ViewIdToTransportId(
-        node->view() ? node->view()->id() : ViewId()));
-    array_builder[i] = node_builder.Finish();
+    INodePtr inode(INode::New());
+    inode->parent_id = NodeIdToTransportId(parent ? parent->id() : NodeId());
+    inode->node_id = NodeIdToTransportId(node->id());
+    inode->view_id = ViewIdToTransportId(
+        node->view() ? node->view()->id() : ViewId());
+    array[i] = inode.Pass();
   }
-  return array_builder.Finish();
+  return array.Pass();
 }
 
 void ViewManagerConnection::CreateNode(
     TransportNodeId transport_node_id,
     const Callback<void(bool)>& callback) {
   const NodeId node_id(NodeIdFromTransportId(transport_node_id));
   if (node_id.connection_id != id_ ||
       node_map_.find(node_id.node_id) != node_map_.end()) {
     callback.Run(false);
     return;
   }
   node_map_[node_id.node_id] = new Node(this, node_id);
   known_nodes_.insert(transport_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 30 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;
   if (CanGetNodeTree(node)) {
     GetDescendants(node, &nodes);
     for (size_t i = 0; i < nodes.size(); ++i)
       known_nodes_.insert(NodeIdToTransportId(nodes[i]->id()));
   }
   callback.Run(NodesToINodes(nodes));
 }
 
@@ skipping 50 matching lines @@
   SkBitmap bitmap;
   gfx::PNGCodec::Decode(static_cast<const unsigned char*>(handle_data),
                         buffer_size, &bitmap);
   view->SetBitmap(bitmap);
   UnmapBuffer(handle_data);
   callback.Run(true);
 }
 
 void ViewManagerConnection::SetRoots(
     TransportConnectionId connection_id,
-    const Array<TransportNodeId>& transport_node_ids,
+    Array<TransportNodeId> transport_node_ids,
     const Callback<void(bool)>& callback) {
   ViewManagerConnection* connection =
       root_node_manager_->GetConnection(connection_id);
   callback.Run(connection &&
                connection->ProcessSetRoots(id_, transport_node_ids));
 }
 
 void ViewManagerConnection::SetNodeBounds(
     TransportNodeId node_id,
-    const Rect& bounds,
+    RectPtr bounds,
     const Callback<void(bool)>& callback) {
   if (NodeIdFromTransportId(node_id).connection_id != id_) {
     callback.Run(false);
     return;
   }
 
   Node* node = GetNode(NodeIdFromTransportId(node_id));
   if (!node) {
     callback.Run(false);
     return;
   }
 
   RootNodeManager::ScopedChange change(
       this, root_node_manager_,
       RootNodeManager::CHANGE_TYPE_DONT_ADVANCE_SERVER_CHANGE_ID, false);
   gfx::Rect old_bounds = node->window()->bounds();
-  node->window()->SetBounds(bounds);
-  root_node_manager_->ProcessNodeBoundsChanged(node, old_bounds, bounds);
+  node->window()->SetBounds(bounds.To<gfx::Rect>());
+  root_node_manager_->ProcessNodeBoundsChanged(
+      node, old_bounds, bounds.To<gfx::Rect>());
   callback.Run(true);
 }
 
 void ViewManagerConnection::OnNodeHierarchyChanged(const Node* node,
                                                    const Node* new_parent,
                                                    const Node* old_parent) {
   root_node_manager_->ProcessNodeHierarchyChanged(node, new_parent, old_parent);
 }
 
 void ViewManagerConnection::OnNodeViewReplaced(const Node* node,
                                                const View* new_view,
                                                const View* old_view) {
   root_node_manager_->ProcessNodeViewReplaced(node, new_view, old_view);
 }
 
 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()->OnViewManagerConnectionEstablished(
       id_,
       root_node_manager_->next_server_change_id(),
       NodesToINodes(to_send));
 }
 
 }  // namespace service
 }  // namespace view_manager
 }  // namespace mojo