Remove [Client=] annotation from ServiceProvider

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 "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/window_manager/public/interfaces/window_manager_internal.mojom.h"
 #include "services/view_manager/connection_manager.h"
 #include "services/view_manager/default_access_policy.h"
 #include "services/view_manager/display_manager.h"
 #include "services/view_manager/server_view.h"
 #include "services/view_manager/window_manager_access_policy.h"
 
 using mojo::Array;
 using mojo::Callback;
 using mojo::Id;
 using mojo::InterfaceRequest;
 using mojo::OrderDirection;
 using mojo::Rect;
 using mojo::ServiceProvider;
+using mojo::ServiceProviderPtr;
 using mojo::String;
 using mojo::ViewDataPtr;
 
 namespace view_manager {
 
 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) {
   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,
-    InterfaceRequest<ServiceProvider> service_provider) {
+void ViewManagerServiceImpl::Init(mojo::ViewManagerClient* client,
+                                  InterfaceRequest<ServiceProvider> services,
+                                  ServiceProviderPtr exposed_services) {
   DCHECK(!client_);
   client_ = client;
   std::vector<const ServerView*> to_send;
   if (root_.get())
     GetUnknownViewsFrom(GetView(*root_), &to_send);
 
   mojo::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());
+                  services.Pass(), exposed_services.Pass(),
+                  pipe.handle0.Pass());
 }
 
 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 51 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;
 }
 
-bool ViewManagerServiceImpl::Embed(
-    const std::string& url,
-    const ViewId& view_id,
-    InterfaceRequest<ServiceProvider> service_provider) {
+bool ViewManagerServiceImpl::Embed(const std::string& url,
+                                   const ViewId& view_id,
+                                   InterfaceRequest<ServiceProvider> services,
+                                   ServiceProviderPtr exposed_services) {
   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());
+  connection_manager_->EmbedAtView(id_, url, view_id, services.Pass(),
+                                   exposed_services.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;
@@ skipping 406 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::Embed(
-    const String& url,
-    Id transport_view_id,
-    InterfaceRequest<ServiceProvider> service_provider,
-    const Callback<void(bool)>& callback) {
+void ViewManagerServiceImpl::Embed(const String& url,
+                                   Id transport_view_id,
+                                   InterfaceRequest<ServiceProvider> services,
+                                   ServiceProviderPtr exposed_services,
+                                   const Callback<void(bool)>& callback) {
   callback.Run(Embed(url.To<std::string>(),
-                     ViewIdFromTransportId(transport_view_id),
-                     service_provider.Pass()));
+                     ViewIdFromTransportId(transport_view_id), services.Pass(),
+                     exposed_services.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 view_manager