Makes ViewManagerServiceImpl track a single root

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 "base/stl_util.h"
 #include "mojo/converters/geometry/geometry_type_converters.h"
 #include "mojo/converters/input_events/input_events_type_converters.h"
@@ skipping 13 matching lines @@
     const std::string& url,
     const ViewId& root_id,
     InterfaceRequest<ServiceProvider> service_provider)
     : connection_manager_(connection_manager),
       id_(connection_manager_->GetAndAdvanceNextConnectionId()),
       url_(url),
       creator_id_(creator_id),
       creator_url_(creator_url),
       service_provider_(service_provider.Pass()) {
   CHECK(GetView(root_id));
-  roots_.insert(ViewIdToTransportId(root_id));
+  root_.reset(new ViewId(root_id));
   if (root_id == RootViewId())
     access_policy_.reset(new WindowManagerAccessPolicy(id_, this));
   else
     access_policy_.reset(new DefaultAccessPolicy(id_, this));
 }
 
 ViewManagerServiceImpl::~ViewManagerServiceImpl() {
   DestroyViews();
 }
 
 const ServerView* ViewManagerServiceImpl::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 connection_manager_->GetView(id);
 }
 
-bool ViewManagerServiceImpl::HasRoot(const ViewId& id) const {
-  return roots_.find(ViewIdToTransportId(id)) != roots_.end();
+bool ViewManagerServiceImpl::IsRoot(const ViewId& id) const {
+  return root_.get() && *root_ == id;
 }
 
 void ViewManagerServiceImpl::OnWillDestroyViewManagerServiceImpl(
     ViewManagerServiceImpl* connection) {
   if (creator_id_ == connection->id())
     creator_id_ = kInvalidConnectionId;
-  ViewId embedded_root_id;
-  if (ProvidesRoot(connection, &embedded_root_id))
-    client()->OnEmbeddedAppDisconnected(ViewIdToTransportId(embedded_root_id));
+  if (connection->root_ && connection->root_->connection_id == id_ &&
+      view_map_.count(connection->root_->view_id) > 0) {
+    client()->OnEmbeddedAppDisconnected(
+        ViewIdToTransportId(*connection->root_));
+  }
 }
 
 void ViewManagerServiceImpl::ProcessViewBoundsChanged(
     const ServerView* view,
     const gfx::Rect& old_bounds,
     const gfx::Rect& new_bounds,
     bool originated_change) {
   if (originated_change || !IsViewKnown(view))
     return;
   client()->OnViewBoundsChanged(ViewIdToTransportId(view->id()),
@@ skipping 79 matching lines @@
   client()->OnViewReordered(ViewIdToTransportId(view->id()),
                             ViewIdToTransportId(relative_view->id()),
                             direction);
 }
 
 void ViewManagerServiceImpl::ProcessViewDeleted(const ViewId& view,
                                                 bool originated_change) {
   view_map_.erase(view.view_id);
 
   const bool in_known = known_views_.erase(ViewIdToTransportId(view)) > 0;
-  roots_.erase(ViewIdToTransportId(view));
+  if (IsRoot(view))
+    root_.reset();
 
   if (originated_change)
     return;
 
   if (in_known) {
     client()->OnViewDeleted(ViewIdToTransportId(view));
     connection_manager_->OnConnectionMessagedClient(id_);
   }
 }
 
@@ skipping 23 matching lines @@
 }
 
 void ViewManagerServiceImpl::OnConnectionError() {
   connection_manager_->OnConnectionError(this);
 }
 
 bool ViewManagerServiceImpl::IsViewKnown(const ServerView* view) const {
   return known_views_.count(ViewIdToTransportId(view->id())) > 0;
 }
 
-bool ViewManagerServiceImpl::ProvidesRoot(
-    const ViewManagerServiceImpl* connection,
-    ViewId* root_id) const {
-  for (Id transport_id : connection->roots()) {
-    const ViewId view_id(ViewIdFromTransportId(transport_id));
-    if (id_ == view_id.connection_id && view_map_.count(view_id.view_id) > 0) {
-      *root_id = view_id;
-      return true;
-    }
-  }
-  return false;
-}
-
 bool ViewManagerServiceImpl::CanReorderView(const ServerView* view,
                                             const ServerView* relative_view,
                                             OrderDirection direction) const {
   if (!view || !relative_view)
     return false;
 
   if (!view->parent() || view->parent() != relative_view->parent())
     return false;
 
   if (!access_policy_->CanReorderView(view, relative_view, direction))
@@ skipping 43 matching lines @@
     if (local_views)
       local_views->push_back(GetView(view->id()));
     return;
   }
   known_views_.erase(ViewIdToTransportId(view->id()));
   std::vector<const ServerView*> children = view->GetChildren();
   for (size_t i = 0; i < children.size(); ++i)
     RemoveFromKnown(children[i], local_views);
 }
 
-void ViewManagerServiceImpl::RemoveRoot(const ViewId& view_id) {
-  const Id transport_view_id(ViewIdToTransportId(view_id));
-  CHECK(roots_.count(transport_view_id) > 0);
-
-  roots_.erase(transport_view_id);
-
+void ViewManagerServiceImpl::RemoveRoot() {
+  CHECK(root_.get());
+  const ViewId root_id(*root_);
+  root_.reset();
   // No need to do anything if we created the view.
-  if (view_id.connection_id == id_)
+  if (root_id.connection_id == id_)
     return;
 
-  client()->OnViewDeleted(transport_view_id);
+  client()->OnViewDeleted(ViewIdToTransportId(root_id));
   connection_manager_->OnConnectionMessagedClient(id_);
 
   // This connection no longer knows about the view. Unparent any views that
   // were parented to views in the root.
   std::vector<ServerView*> local_views;
-  RemoveFromKnown(GetView(view_id), &local_views);
+  RemoveFromKnown(GetView(root_id), &local_views);
   for (size_t i = 0; i < local_views.size(); ++i)
     local_views[i]->parent()->Remove(local_views[i]);
 }
 
 void ViewManagerServiceImpl::RemoveChildrenAsPartOfEmbed(
     const ViewId& view_id) {
   ServerView* view = GetView(view_id);
   CHECK(view);
   CHECK(view->id().connection_id == view_id.connection_id);
   std::vector<ServerView*> children = view->GetChildren();
@@ skipping 39 matching lines @@
   if (!access_policy_->CanDescendIntoViewForViewTree(view))
     return;
 
   std::vector<const ServerView*> children(view->GetChildren());
   for (size_t i = 0 ; i < children.size(); ++i)
     GetViewTreeImpl(children[i], views);
 }
 
 void ViewManagerServiceImpl::NotifyDrawnStateChanged(const ServerView* view,
                                                      bool new_drawn_value) {
-  // Even though we don't know about view, it may be an ancestor of one of our
-  // roots, in which case the change may effect our roots drawn state.
-  for (ViewIdSet::iterator i = roots_.begin(); i != roots_.end(); ++i) {
-    const ServerView* root = GetView(ViewIdFromTransportId(*i));
-    DCHECK(root);
-    if (view->Contains(root) &&
-        (new_drawn_value != root->IsDrawn(connection_manager_->root()))) {
-      client()->OnViewDrawnStateChanged(ViewIdToTransportId(root->id()),
-                                        new_drawn_value);
-    }
+  // Even though we don't know about view, it may be an ancestor of our root, in
+  // which case the change may effect our roots drawn state.
+  if (!root_.get())
+    return;
+
+  const ServerView* root = GetView(*root_);
+  DCHECK(root);
+  if (view->Contains(root) &&
+      (new_drawn_value != root->IsDrawn(connection_manager_->root()))) {
+    client()->OnViewDrawnStateChanged(ViewIdToTransportId(root->id()),
+                                      new_drawn_value);
   }
 }
 
 void ViewManagerServiceImpl::DestroyViews() {
   if (!view_map_.empty()) {
     ConnectionManager::ScopedChange change(this, connection_manager_, true);
     // If we get here from the destructor we're not going to get
     // ProcessViewDeleted(). Copy the map and delete from the copy so that we
     // don't have to worry about whether |view_map_| changes or not.
     ViewMap view_map_copy;
@@ skipping 169 matching lines @@
   // Only allow a node to be the root for one connection.
   const ViewId view_id(ViewIdFromTransportId(transport_view_id));
   ViewManagerServiceImpl* existing_owner =
       connection_manager_->GetConnectionWithRoot(view_id);
 
   ConnectionManager::ScopedChange change(this, connection_manager_, true);
   RemoveChildrenAsPartOfEmbed(view_id);
   if (existing_owner) {
     // Never message the originating connection.
     connection_manager_->OnConnectionMessagedClient(id_);
-    existing_owner->RemoveRoot(view_id);
+    existing_owner->RemoveRoot();
   }
   connection_manager_->EmbedAtView(id_, url, transport_view_id, spir.Pass());
   callback.Run(true);
 }
 
 void ViewManagerServiceImpl::OnConnectionEstablished() {
   std::vector<const ServerView*> to_send;
-  for (ViewIdSet::const_iterator i = roots_.begin(); i != roots_.end(); ++i)
-    GetUnknownViewsFrom(GetView(ViewIdFromTransportId(*i)), &to_send);
+  if (root_.get())
+    GetUnknownViewsFrom(GetView(*root_), &to_send);
 
   MessagePipe pipe;
   connection_manager_->wm_internal()->CreateWindowManagerForViewManagerClient(
       id_, pipe.handle1.Pass());
   client()->OnEmbed(id_,
                     creator_url_,
                     ViewToViewData(to_send.front()),
                     service_provider_.Pass(),
                     pipe.handle0.Pass());
 }
 
-const base::hash_set<Id>&
-ViewManagerServiceImpl::GetRootsForAccessPolicy() const {
-  return roots_;
+bool ViewManagerServiceImpl::IsRootForAccessPolicy(const ViewId& id) const {
+  return IsRoot(id);
 }
 
 bool ViewManagerServiceImpl::IsViewKnownForAccessPolicy(
     const ServerView* view) const {
   return IsViewKnown(view);
 }
 
 bool ViewManagerServiceImpl::IsViewRootOfAnotherConnectionForAccessPolicy(
     const ServerView* view) const {
   ViewManagerServiceImpl* connection =
       connection_manager_->GetConnectionWithRoot(view->id());
   return connection && connection != this;
 }
 
 }  // namespace service
 }  // namespace mojo