Removes ServiceProviders from ViewManager::Embed

components/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 "components/view_manager/view_manager_service_impl.h"
 
 #include "base/bind.h"
 #include "base/stl_util.h"
 #include "components/view_manager/connection_manager.h"
 #include "components/view_manager/default_access_policy.h"
@@ skipping 17 matching lines @@
 
 namespace view_manager {
 
 // Contains information needed to complete an Embed(). See description of
 // |pending_embeds_| for more details.
 struct ViewManagerServiceImpl::PendingEmbed
     : public base::RefCounted<PendingEmbed> {
   PendingEmbed() : embed_root(nullptr) {}
 
   ViewManagerServiceImpl* embed_root;
-  mojo::URLRequestPtr url_request;
   ViewId view_id;
   mojo::Callback<void(bool)> callback;
 
  private:
   friend class base::RefCounted<PendingEmbed>;
 
   ~PendingEmbed() {}
 };
 
 ViewManagerServiceImpl::ViewManagerServiceImpl(
     ConnectionManager* connection_manager,
     mojo::ConnectionSpecificId creator_id,
-    const std::string& creator_url,
-    const std::string& url,
     const ViewId& root_id)
     : connection_manager_(connection_manager),
       id_(connection_manager_->GetAndAdvanceNextConnectionId()),
-      url_(url),
       creator_id_(creator_id),
-      creator_url_(creator_url),
       client_(nullptr),
       is_embed_root_(false) {
   CHECK(GetView(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();
 }
 
 void ViewManagerServiceImpl::Init(mojo::ViewManagerClient* client,
-                                  mojo::ViewManagerServicePtr service_ptr,
-                                  InterfaceRequest<ServiceProvider> services,
-                                  ServiceProviderPtr exposed_services) {
+                                  mojo::ViewManagerServicePtr service_ptr) {
   DCHECK(!client_);
   client_ = client;
   std::vector<const ServerView*> to_send;
   if (root_.get())
     GetUnknownViewsFrom(GetView(*root_), &to_send);
 
   const ServerView* focused_view = connection_manager_->GetFocusedView();
   if (focused_view)
     focused_view = access_policy_->GetViewForFocusChange(focused_view);
   const mojo::Id focused_view_transport_id(
       ViewIdToTransportId(focused_view ? focused_view->id() : ViewId()));
 
-  client->OnEmbed(id_, creator_url_, ViewToViewData(to_send.front()),
-                  service_ptr.Pass(), services.Pass(), exposed_services.Pass(),
+  client->OnEmbed(id_, ViewToViewData(to_send.front()), service_ptr.Pass(),
                   focused_view_transport_id);
 }
 
 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);
 }
@@ skipping 53 matching lines @@
   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;
 }
 
-void ViewManagerServiceImpl::SetEmbedRoot() {
-  is_embed_root_ = true;
-}
-
-void ViewManagerServiceImpl::Embed(mojo::URLRequestPtr request,
-                                   const ViewId& view_id,
-                                   EmbedType type,
-                                   InterfaceRequest<ServiceProvider> services,
-                                   ServiceProviderPtr exposed_services,
-                                   const mojo::Callback<void(bool)>& callback) {
+void ViewManagerServiceImpl::EmbedAllowingReembed(
+    const ViewId& view_id,
+    mojo::URLRequestPtr request,
+    const mojo::Callback<void(bool)>& callback) {
   if (!CanEmbed(view_id)) {
     callback.Run(false);
     return;
   }
 
   ViewManagerServiceImpl* embed_root = nullptr;
 
-  // Only the creator is allowed to reset reembed.
   ServerView* view = GetView(view_id);
   DCHECK(view);  // CanEmbed() returns true only if |view_id| is valid.
   if (view->id().connection_id == id_) {
-    view->set_allows_reembed(type == EmbedType::ALLOW_REEMBED);
+    view->set_allows_reembed(true);
 
     // Only consult the embed root if the creator is doing the embed. If someone
     // other than the creator is doing the embed they were granted embed access.
     embed_root = connection_manager_->GetEmbedRoot(this);
   }
 
   if (!embed_root) {
     PrepareForEmbed(view_id);
-    connection_manager_->EmbedAtView(id_, request.Pass(), view_id,
-                                     services.Pass(), exposed_services.Pass());
+    connection_manager_->EmbedAtView(id_, view_id, request.Pass());
     callback.Run(true);
     return;
   }
 
   // There is an embed root. We have to query it before completing the embed.
   scoped_refptr<PendingEmbed> pending_embed(new PendingEmbed);
   pending_embeds_.insert(pending_embed);
   pending_embed->embed_root = embed_root;
   pending_embed->view_id = view_id;
-  pending_embed->url_request = request.Pass();
   pending_embed->callback = callback;
   pending_embeds_.insert(pending_embed);
-  embed_root->client()->OnWillEmbed(
-      ViewIdToTransportId(view_id), services.Pass(), exposed_services.Pass(),
-      base::Bind(&ViewManagerServiceImpl::OnWillEmbedDone,
+  embed_root->client()->OnEmbedForDescendant(
+      ViewIdToTransportId(view_id), request.Pass(),
+      base::Bind(&ViewManagerServiceImpl::OnEmbedForDescendantDone,
                  base::Unretained(this), pending_embed));
 }
 
 bool ViewManagerServiceImpl::Embed(const ViewId& view_id,
                                    mojo::ViewManagerClientPtr client) {
-  // TODO(sky): wire up embed root.
   if (!client.get() || !CanEmbed(view_id))
     return false;
   PrepareForEmbed(view_id);
   connection_manager_->EmbedAtView(id_, view_id, client.Pass());
   return true;
 }
 
 void ViewManagerServiceImpl::ProcessViewBoundsChanged(
     const ServerView* view,
     const gfx::Rect& old_bounds,
@@ skipping 333 matching lines @@
 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();
   for (size_t i = 0; i < children.size(); ++i)
     view->Remove(children[i]);
 }
 
-void ViewManagerServiceImpl::OnWillEmbedDone(
+void ViewManagerServiceImpl::OnEmbedForDescendantDone(
     scoped_refptr<PendingEmbed> pending_embed,
-    bool allow_embed,
-    mojo::InterfaceRequest<mojo::ServiceProvider> services,
-    mojo::ServiceProviderPtr exposed_services) {
+    mojo::ViewManagerClientPtr client) {
   if (!pending_embeds_.count(pending_embed.get()))
     return;
 
-  allow_embed = allow_embed && CanEmbed(pending_embed->view_id);
+  const bool allow_embed = client.get() && CanEmbed(pending_embed->view_id);
   if (allow_embed) {
     PrepareForEmbed(pending_embed->view_id);
-    connection_manager_->EmbedAtView(id_, pending_embed->url_request.Pass(),
-                                     pending_embed->view_id, services.Pass(),
-                                     exposed_services.Pass());
+    connection_manager_->EmbedAtView(id_, pending_embed->view_id,
+                                     client.Pass());
   }
   RemovePendingEmbedAndNotifyCallback(pending_embed.get(), allow_embed);
 }
 
 void ViewManagerServiceImpl::InvalidatePendingEmbedForConnection(
     ViewManagerServiceImpl* connection) {
   if (pending_embeds_.empty())
     return;
   std::set<scoped_refptr<PendingEmbed>> copy(pending_embeds_);
   for (auto& embed : copy) {
@@ skipping 132 matching lines @@
     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::EmbedRequest(
-    mojo::URLRequestPtr request,
-    Id transport_view_id,
-    InterfaceRequest<ServiceProvider> services,
-    ServiceProviderPtr exposed_services,
-    const Callback<void(bool)>& callback) {
-  Embed(request.Pass(), ViewIdFromTransportId(transport_view_id),
-        EmbedType::NO_REEMBED, services.Pass(), exposed_services.Pass(),
-        callback);
-}
-
-void ViewManagerServiceImpl::EmbedAllowingReembed(
-    mojo::URLRequestPtr request,
-    mojo::Id transport_view_id,
-    const mojo::Callback<void(bool)>& callback) {
-  Embed(request.Pass(), ViewIdFromTransportId(transport_view_id),
-        EmbedType::ALLOW_REEMBED, nullptr, nullptr, callback);
+void ViewManagerServiceImpl::SetEmbedRoot() {
+  is_embed_root_ = true;
 }
 
 void ViewManagerServiceImpl::Embed(mojo::Id transport_view_id,
                                    mojo::ViewManagerClientPtr client,
                                    const mojo::Callback<void(bool)>& callback) {
   callback.Run(Embed(ViewIdFromTransportId(transport_view_id), client.Pass()));
 }
 
+void ViewManagerServiceImpl::EmbedAllowingReembed(
+    mojo::Id transport_view_id,
+    mojo::URLRequestPtr request,
+    const mojo::Callback<void(bool)>& callback) {
+  EmbedAllowingReembed(ViewIdFromTransportId(transport_view_id), request.Pass(),
+                       callback);
+}
+
 void ViewManagerServiceImpl::SetFocus(uint32_t view_id,
                                       const SetFocusCallback& callback) {
   ServerView* view = GetView(ViewIdFromTransportId(view_id));
   bool success = view && view->IsDrawn(connection_manager_->root()) &&
                  access_policy_->CanSetFocus(view);
   if (success) {
     ConnectionManager::ScopedChange change(this, connection_manager_, false);
     connection_manager_->SetFocusedView(view);
   }
   callback.Run(success);
@@ skipping 13 matching lines @@
   ViewManagerServiceImpl* connection =
       connection_manager_->GetConnectionWithRoot(view->id());
   return connection && connection != this;
 }
 
 bool ViewManagerServiceImpl::IsEmbedRootForAccessPolicy() {
   return is_embed_root_;
 }
 
 }  // namespace view_manager