Removes ServiceProviders from ViewManager::Embed

components/view_manager/public/cpp/lib/view_manager_client_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/public/cpp/lib/view_manager_client_impl.h"
 
 #include "components/view_manager/public/cpp/lib/view_private.h"
 #include "components/view_manager/public/cpp/util.h"
 #include "components/view_manager/public/cpp/view_manager_delegate.h"
 #include "components/view_manager/public/cpp/view_observer.h"
@@ skipping 184 matching lines @@
     Id view_id,
     const std::string& name,
     const std::vector<uint8_t>& data) {
   DCHECK(service_);
   service_->SetViewProperty(view_id,
                             String(name),
                             Array<uint8_t>::From(data),
                             ActionCompletedCallback());
 }
 
-void ViewManagerClientImpl::Embed(const String& url, Id view_id) {
-  mojo::URLRequestPtr request(mojo::URLRequest::New());
-  request->url = mojo::String::From(url);
-  Embed(request.Pass(), view_id, nullptr, nullptr);
-}
-
-void ViewManagerClientImpl::Embed(mojo::URLRequestPtr request,
-                                  Id view_id,
-                                  InterfaceRequest<ServiceProvider> services,
-                                  ServiceProviderPtr exposed_services) {
-  DCHECK(service_);
-  service_->EmbedRequest(request.Pass(), view_id, services.Pass(),
-                         exposed_services.Pass(), ActionCompletedCallback());
-}
-
 void ViewManagerClientImpl::Embed(Id view_id, ViewManagerClientPtr client) {
   DCHECK(service_);
   service_->Embed(view_id, client.Pass(), ActionCompletedCallback());
 }
 
 void ViewManagerClientImpl::EmbedAllowingReembed(mojo::URLRequestPtr request,
                                                  Id view_id) {
   DCHECK(service_);
-  service_->EmbedAllowingReembed(request.Pass(), view_id,
+  service_->EmbedAllowingReembed(view_id, request.Pass(),
                                  ActionCompletedCallback());
 }
 
 void ViewManagerClientImpl::AddView(View* view) {
   DCHECK(views_.find(view->id()) == views_.end());
   views_[view->id()] = view;
 }
 
 void ViewManagerClientImpl::RemoveView(Id view_id) {
   if (focused_view_ && focused_view_->id() == view_id)
@@ skipping 16 matching lines @@
 
 Id ViewManagerClientImpl::CreateViewOnServer() {
   DCHECK(service_);
   const Id view_id = MakeTransportId(connection_id_, ++next_id_);
   service_->CreateView(view_id, [this](ErrorCode code) {
     OnActionCompleted(code == ERROR_CODE_NONE);
   });
   return view_id;
 }
 
-const std::string& ViewManagerClientImpl::GetEmbedderURL() const {
-  return creator_url_;
-}
-
 View* ViewManagerClientImpl::GetRoot() {
   return root_;
 }
 
 View* ViewManagerClientImpl::GetViewById(Id id) {
   IdToViewMap::const_iterator it = views_.find(id);
   return it != views_.end() ? it->second : NULL;
 }
 
 View* ViewManagerClientImpl::GetFocusedView() {
   return focused_view_;
 }
 
 View* ViewManagerClientImpl::CreateView() {
   View* view = new View(this, CreateViewOnServer());
   AddView(view);
   return view;
 }
 
 void ViewManagerClientImpl::SetEmbedRoot() {
   // TODO(sky): this isn't right. The server may ignore the call.
   is_embed_root_ = true;
   service_->SetEmbedRoot();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // ViewManagerClientImpl, ViewManagerClient implementation:
 
 void ViewManagerClientImpl::OnEmbed(ConnectionSpecificId connection_id,
-                                    const String& creator_url,
                                     ViewDataPtr root_data,
                                     ViewManagerServicePtr view_manager_service,
-                                    InterfaceRequest<ServiceProvider> services,
-                                    ServiceProviderPtr exposed_services,
                                     Id focused_view_id) {
   if (view_manager_service) {
     DCHECK(!service_);
     service_ = view_manager_service.Pass();
     service_.set_error_handler(this);
   }
   connection_id_ = connection_id;
-  creator_url_ = String::From(creator_url);
 
   DCHECK(!root_);
   root_ = AddViewToViewManager(this, nullptr, root_data);
   root_observer_.reset(new RootObserver(root_));
 
   focused_view_ = GetViewById(focused_view_id);
 
-  delegate_->OnEmbed(root_, services.Pass(), exposed_services.Pass());
+  delegate_->OnEmbed(root_);
 }
 
-void ViewManagerClientImpl::OnWillEmbed(
+void ViewManagerClientImpl::OnEmbedForDescendant(
     Id view_id,
-    InterfaceRequest<ServiceProvider> services,
-    ServiceProviderPtr exposed_services,
-    const OnWillEmbedCallback& callback) {
+    mojo::URLRequestPtr request,
+    const OnEmbedForDescendantCallback& callback) {
   View* view = GetViewById(view_id);
-  bool allow_embed = false;
+  ViewManagerClientPtr client;
   if (view)
-    allow_embed = delegate_->OnWillEmbed(view, &services, &exposed_services);
-  callback.Run(allow_embed, services.Pass(), exposed_services.Pass());
+    delegate_->OnEmbedForDescendant(view, request.Pass(), &client);
+  callback.Run(client.Pass());
 }
 
 void ViewManagerClientImpl::OnEmbeddedAppDisconnected(Id view_id) {
   View* view = GetViewById(view_id);
   if (view) {
     FOR_EACH_OBSERVER(ViewObserver, *ViewPrivate(view).observers(),
                       OnViewEmbeddedAppDisconnected(view));
   }
 }
 
@@ skipping 136 matching lines @@
 void ViewManagerClientImpl::OnActionCompleted(bool success) {
   if (!change_acked_callback_.is_null())
     change_acked_callback_.Run();
 }
 
 Callback<void(bool)> ViewManagerClientImpl::ActionCompletedCallback() {
   return [this](bool success) { OnActionCompleted(success); };
 }
 
 }  // namespace mojo