Adds a CloneAndAnimate function to WindowManagerInternalClient

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"
 #include "mojo/converters/surfaces/surfaces_type_converters.h"
+#include "mojo/services/public/interfaces/window_manager/window_manager_internal.mojom.h"
 #include "mojo/services/view_manager/connection_manager.h"
 #include "mojo/services/view_manager/default_access_policy.h"
 #include "mojo/services/view_manager/server_view.h"
 #include "mojo/services/view_manager/window_manager_access_policy.h"
 
 namespace mojo {
 namespace service {
 
 ViewManagerServiceImpl::ViewManagerServiceImpl(
     ConnectionManager* connection_manager,
@@ skipping 36 matching lines @@
 }
 
 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);
 }
 
-ErrorCode ViewManagerServiceImpl::CreateView(const ViewId& view_id) {
-  if (view_id.connection_id != id_)
-    return ERROR_CODE_ILLEGAL_ARGUMENT;
-  if (view_map_.find(view_id.view_id) != view_map_.end())
-    return ERROR_CODE_VALUE_IN_USE;
-  view_map_[view_id.view_id] = new ServerView(connection_manager_, view_id);
-  known_views_.insert(ViewIdToTransportId(view_id));
-  return ERROR_CODE_NONE;
-}
-
 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;
   if (connection->root_ && connection->root_->connection_id == id_ &&
       view_map_.count(connection->root_->view_id) > 0) {
     client()->OnEmbeddedAppDisconnected(
         ViewIdToTransportId(*connection->root_));
   }
   if (root_.get() && root_->connection_id == connection->id())
     root_.reset();
 }
 
+ErrorCode ViewManagerServiceImpl::CreateView(const ViewId& view_id) {
+  if (view_id.connection_id != id_)
+    return ERROR_CODE_ILLEGAL_ARGUMENT;
+  if (view_map_.find(view_id.view_id) != view_map_.end())
+    return ERROR_CODE_VALUE_IN_USE;
+  view_map_[view_id.view_id] = new ServerView(connection_manager_, view_id);
+  known_views_.insert(ViewIdToTransportId(view_id));
+  return ERROR_CODE_NONE;
+}
+
+bool ViewManagerServiceImpl::AddView(const ViewId& parent_id,
+                                     const ViewId& child_id) {
+  ServerView* parent = GetView(parent_id);
+  ServerView* child = GetView(child_id);
+  if (parent && child && child->parent() != parent &&
+      !child->Contains(parent) && access_policy_->CanAddView(parent, child)) {
+    ConnectionManager::ScopedChange change(this, connection_manager_, false);
+    parent->Add(child);
+    return true;
+  }
+  return false;
+}
+
+std::vector<const ServerView*> ViewManagerServiceImpl::GetViewTree(
+    const ViewId& view_id) const {
+  const ServerView* view = GetView(view_id);
+  std::vector<const ServerView*> views;
+  if (view)
+    GetViewTreeImpl(view, &views);
+  return views;
+}
+
+bool ViewManagerServiceImpl::SetViewVisibility(const ViewId& view_id,
+                                               bool visible) {
+  ServerView* view = GetView(view_id);
+  if (!view || view->visible() == visible ||
+      !access_policy_->CanChangeViewVisibility(view)) {
+    return false;
+  }
+  ConnectionManager::ScopedChange change(this, connection_manager_, false);
+  view->SetVisible(visible);
+  return true;
+}
+
+bool ViewManagerServiceImpl::Embed(
+    const std::string& url,
+    const ViewId& view_id,
+    InterfaceRequest<ServiceProvider> service_provider) {
+  const ServerView* view = GetView(view_id);
+  if (!view || !access_policy_->CanEmbed(view))
+    return false;
+
+  // Only allow a node to be the root for one connection.
+  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();
+  }
+  connection_manager_->EmbedAtView(id_, url, view_id, service_provider.Pass());
+  return true;
+}
+
 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()),
                                 Rect::From(old_bounds),
                                 Rect::From(new_bounds));
@@ skipping 76 matching lines @@
                             ViewIdToTransportId(relative_view->id()),
                             direction);
 }
 
 void ViewManagerServiceImpl::ProcessViewDeleted(const ViewId& view,
                                                 bool originated_change) {
   if (view.connection_id == id_)
     view_map_.erase(view.view_id);
 
   const bool in_known = known_views_.erase(ViewIdToTransportId(view)) > 0;
+
   if (IsRoot(view))
     root_.reset();
 
   if (originated_change)
     return;
 
   if (in_known) {
     client()->OnViewDeleted(ViewIdToTransportId(view));
     connection_manager_->OnConnectionMessagedClient(id_);
   }
@@ skipping 207 matching lines @@
         connection_manager_->GetConnection(view->id().connection_id);
     success = connection && connection->DeleteViewImpl(this, view);
   }
   callback.Run(success);
 }
 
 void ViewManagerServiceImpl::AddView(
     Id parent_id,
     Id child_id,
     const Callback<void(bool)>& callback) {
-  bool success = false;
-  ServerView* parent = GetView(ViewIdFromTransportId(parent_id));
-  ServerView* child = GetView(ViewIdFromTransportId(child_id));
-  if (parent && child && child->parent() != parent &&
-      !child->Contains(parent) && access_policy_->CanAddView(parent, child)) {
-    success = true;
-    ConnectionManager::ScopedChange change(this, connection_manager_, false);
-    parent->Add(child);
-  }
-  callback.Run(success);
+  callback.Run(AddView(ViewIdFromTransportId(parent_id),
+                       ViewIdFromTransportId(child_id)));
 }
 
 void ViewManagerServiceImpl::RemoveViewFromParent(
     Id view_id,
     const Callback<void(bool)>& callback) {
   bool success = false;
   ServerView* view = GetView(ViewIdFromTransportId(view_id));
   if (view && view->parent() && access_policy_->CanRemoveViewFromParent(view)) {
     success = true;
     ConnectionManager::ScopedChange change(this, connection_manager_, false);
@@ skipping 14 matching lines @@
     ConnectionManager::ScopedChange change(this, connection_manager_, false);
     view->parent()->Reorder(view, relative_view, direction);
     connection_manager_->ProcessViewReorder(view, relative_view, direction);
   }
   callback.Run(success);
 }
 
 void ViewManagerServiceImpl::GetViewTree(
     Id view_id,
     const Callback<void(Array<ViewDataPtr>)>& callback) {
-  ServerView* view = GetView(ViewIdFromTransportId(view_id));
-  std::vector<const ServerView*> views;
-  if (view) {
-    GetViewTreeImpl(view, &views);
-    // TODO(sky): this should map in views that weren't none.
-  }
+  std::vector<const ServerView*> views(
+      GetViewTree(ViewIdFromTransportId(view_id)));
   callback.Run(ViewsToViewDatas(views));
 }
 
 void ViewManagerServiceImpl::SetViewSurfaceId(
     Id view_id,
     SurfaceIdPtr surface_id,
     const Callback<void(bool)>& callback) {
   // TODO(sky): add coverage of not being able to set for random node.
   ServerView* view = GetView(ViewIdFromTransportId(view_id));
   if (!view || !access_policy_->CanSetViewSurfaceId(view)) {
@@ skipping 14 matching lines @@
     ConnectionManager::ScopedChange change(this, connection_manager_, false);
     view->SetBounds(bounds.To<gfx::Rect>());
   }
   callback.Run(success);
 }
 
 void ViewManagerServiceImpl::SetViewVisibility(
     Id transport_view_id,
     bool visible,
     const Callback<void(bool)>& callback) {
-  ServerView* view = GetView(ViewIdFromTransportId(transport_view_id));
-  if (!view || view->visible() == visible ||
-      !access_policy_->CanChangeViewVisibility(view)) {
-    callback.Run(false);
-    return;
-  }
-  {
-    ConnectionManager::ScopedChange change(this, connection_manager_, false);
-    view->SetVisible(visible);
-  }
-  callback.Run(true);
+  callback.Run(
+      SetViewVisibility(ViewIdFromTransportId(transport_view_id), visible));
 }
 
 void ViewManagerServiceImpl::SetViewProperty(
     uint32_t view_id,
     const mojo::String& name,
     mojo::Array<uint8_t> value,
     const mojo::Callback<void(bool)>& callback) {
   ServerView* view = GetView(ViewIdFromTransportId(view_id));
   const bool success = view && access_policy_->CanSetViewProperties(view);
   if (success) {
     ConnectionManager::ScopedChange change(this, connection_manager_, false);
 
     if (value.is_null()) {
       view->SetProperty(name, nullptr);
     } else {
       std::vector<uint8_t> data = value.To<std::vector<uint8_t>>();
       view->SetProperty(name, &data);
     }
   }
   callback.Run(success);
 }
 
 void ViewManagerServiceImpl::Embed(
     const String& url,
     Id transport_view_id,
     InterfaceRequest<ServiceProvider> service_provider,
     const Callback<void(bool)>& callback) {
-  const ServerView* view = GetView(ViewIdFromTransportId(transport_view_id));
-  if (!view || !access_policy_->CanEmbed(view)) {
-    callback.Run(false);
-    return;
-  }
-
-  // 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();
-  }
-  connection_manager_->EmbedAtView(id_, url, transport_view_id,
-                                   service_provider.Pass());
-  callback.Run(true);
+  callback.Run(Embed(url.To<std::string>(),
+                     ViewIdFromTransportId(transport_view_id),
+                     service_provider.Pass()));
 }
 
 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