Change type of interface created by mojo:view_manager

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/services/public/cpp/geometry/geometry_type_converters.h"
 #include "mojo/services/view_manager/node.h"
 #include "mojo/services/view_manager/root_node_manager.h"
@@ skipping 16 matching lines @@
 
   std::vector<const Node*> children(node->GetChildren());
   for (size_t i = 0 ; i < children.size(); ++i)
     GetDescendants(children[i], nodes);
 }
 
 }  // namespace
 
 ViewManagerConnection::ViewManagerConnection(RootNodeManager* root_node_manager)
     : root_node_manager_(root_node_manager),
-      id_(0) {
+      id_(root_node_manager_->GetAndAdvanceNextConnectionId()),
+      delete_on_connection_error_(false) {
 }
 
 ViewManagerConnection::~ViewManagerConnection() {
   // Delete any views we own.
   while (!view_map_.empty()) {
     bool result = DeleteViewImpl(this, view_map_.begin()->second->id());
     DCHECK(result);
   }
 
   // We're about to destroy all our nodes. Detach any views from them.
@@ skipping 32 matching lines @@
 
 const View* ViewManagerConnection::GetView(const ViewId& id) const {
   if (id_ == id.connection_id) {
     ViewMap::const_iterator i = view_map_.find(id.view_id);
     return i == view_map_.end() ? NULL : i->second;
   }
   return root_node_manager_->GetView(id);
 }
 
 void ViewManagerConnection::SetRoots(const Array<TransportNodeId>& node_ids) {
-  DCHECK_EQ(0, id_);  // Only valid before connection established.
+  DCHECK(roots_.empty());
   NodeIdSet roots;
   for (size_t i = 0; i < node_ids.size(); ++i) {
     DCHECK(GetNode(NodeIdFromTransportId(node_ids[i])));
     roots.insert(node_ids[i]);
   }
   roots_.swap(roots);
 }
 
 void ViewManagerConnection::ProcessNodeBoundsChanged(
     const Node* node,
@@ skipping 90 matching lines @@
 }
 
 void ViewManagerConnection::ProcessViewDeleted(const ViewId& view,
                                                bool originated_change) {
   if (originated_change)
     return;
   client()->OnViewDeleted(ViewIdToTransportId(view));
 }
 
 void ViewManagerConnection::OnConnectionError() {
-  // TODO(sky): figure out if need to cleanup here if this
-  // ViewManagerConnection is the result of a Connect().
+  if (delete_on_connection_error_)
+    delete this;
 }
 
 bool ViewManagerConnection::CanRemoveNodeFromParent(const Node* node) const {
   if (!node)
     return false;
 
   const Node* parent = node->GetParent();
   if (!parent)
     return false;
 
@@ skipping 394 matching lines @@
   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;
   if (roots_.empty()) {
     GetUnknownNodesFrom(root_node_manager_->root(), &to_send);
   } else {
     for (NodeIdSet::const_iterator i = roots_.begin(); i != roots_.end(); ++i)
       GetUnknownNodesFrom(GetNode(NodeIdFromTransportId(*i)), &to_send);
   }
 
   client()->OnViewManagerConnectionEstablished(
       id_,
       root_node_manager_->next_server_change_id(),
       NodesToINodes(to_send));
 }
 
 }  // namespace service
 }  // namespace view_manager
 }  // namespace mojo