Remove [Client=] annotation from ServiceProvider

examples/window_manager/window_manager.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 "base/bind.h"
 #include "base/macros.h"
 #include "examples/window_manager/debug_panel_host.mojom.h"
 #include "examples/window_manager/window_manager.mojom.h"
 #include "mojo/application/application_runner_chromium.h"
 #include "mojo/converters/geometry/geometry_type_converters.h"
@@ skipping 134 matching lines @@
   const Id content_view_id_;
   const Id launcher_ui_view_id_;
   const Id control_panel_view_id_;
 
   DISALLOW_COPY_AND_ASSIGN(RootLayoutManager);
 };
 
 class Window : public InterfaceFactory<NavigatorHost> {
  public:
   Window(WindowManager* window_manager, View* view)
-      : window_manager_(window_manager), view_(view) {}
+      : window_manager_(window_manager), view_(view) {
+    exposed_services_impl_.AddService<NavigatorHost>(this);
+  }
 
   virtual ~Window() {}
 
   View* view() const { return view_; }
 
   void Embed(const std::string& url) {
-    scoped_ptr<ServiceProviderImpl> service_provider_impl(
-        new ServiceProviderImpl());
-    service_provider_impl->AddService<NavigatorHost>(this);
-    view_->Embed(url, service_provider_impl.Pass());
+    // TODO: Support embedding multiple times?
+    ServiceProviderPtr exposed_services;
+    exposed_services_impl_.Bind(GetProxy(&exposed_services));
+    view_->Embed(url, nullptr, exposed_services.Pass());
   }
 
  private:
   // InterfaceFactory<NavigatorHost>
   virtual void Create(ApplicationConnection* connection,
                       InterfaceRequest<NavigatorHost> request) override {
     BindToRequest(new NavigatorHostImpl(window_manager_, view_->id()),
                   &request);
   }
 
   WindowManager* window_manager_;
   View* view_;
+  ServiceProviderImpl exposed_services_impl_;
 };
 
 class WindowManager : public ApplicationDelegate,
                       public examples::DebugPanelHost,
                       public ViewManagerDelegate,
                       public window_manager::WindowManagerDelegate,
                       public ui::EventHandler,
                       public mojo::InterfaceFactory<examples::DebugPanelHost> {
  public:
   WindowManager()
@@ skipping 71 matching lines @@
 
   virtual bool ConfigureIncomingConnection(
       ApplicationConnection* connection) override {
     connection->AddService(&window_manager_factory_);
     window_manager_app_->ConfigureIncomingConnection(connection);
     return true;
   }
 
   // Overridden from ViewManagerDelegate:
   virtual void OnEmbed(View* root,
-                       ServiceProviderImpl* exported_services,
-                       scoped_ptr<ServiceProvider> imported_services) override {
+                       InterfaceRequest<ServiceProvider> services,
+                       ServiceProviderPtr exposed_services) override {
     DCHECK(!view_manager_);
     view_manager_ = root->view_manager();
 
     View* view = view_manager_->CreateView();
     root->AddChild(view);
     Rect rect;
     rect.width = root->bounds().width;
     rect.height = root->bounds().height;
     view->SetBounds(rect);
     view->SetVisible(true);
@@ skipping 15 matching lines @@
         make_scoped_ptr(new window_manager::BasicFocusRules(root)));
   }
   virtual void OnViewManagerDisconnected(ViewManager* view_manager) override {
     DCHECK_EQ(view_manager_, view_manager);
     view_manager_ = NULL;
     base::MessageLoop::current()->Quit();
   }
 
   // Overridden from WindowManagerDelegate:
   void Embed(const String& url,
-             InterfaceRequest<ServiceProvider> service_provider) override {
+             InterfaceRequest<ServiceProvider> services,
+             ServiceProviderPtr exposed_services) override {
     const Id kInvalidSourceViewId = 0;
     OnLaunch(kInvalidSourceViewId, TARGET_DEFAULT, url);
   }
 
   // Overridden from ui::EventHandler:
   virtual void OnEvent(ui::Event* event) override {
     View* view =
         static_cast<window_manager::ViewTarget*>(event->target())->view();
     if (event->type() == ui::ET_MOUSE_PRESSED)
       view->SetFocus();
@@ skipping 75 matching lines @@
 
     Rect bounds;
     bounds.x = root->bounds().width - kControlPanelWidth - kBorderInset;
     bounds.y = kBorderInset * 2 + kTextfieldHeight;
     bounds.width = kControlPanelWidth;
     bounds.height =
         root->bounds().height - kBorderInset * 3 - kTextfieldHeight;
     view->SetBounds(bounds);
     view->SetVisible(true);
 
-    scoped_ptr<mojo::ServiceProviderImpl> exported_services(
-        new mojo::ServiceProviderImpl());
-    exported_services->AddService(this);
+    ServiceProviderPtr exposed_services;
+    control_panel_exposed_services_impl_.Bind(GetProxy(&exposed_services));
+    control_panel_exposed_services_impl_.AddService(this);
 
     GURL frame_url = url_.Resolve("/examples/window_manager/debug_panel.sky");
-    debug_panel_ = view->Embed(frame_url.spec(), exported_services.Pass());
+    view->Embed(frame_url.spec(), nullptr, exposed_services.Pass());
 
     return view->id();
   }
 
   WindowVector::iterator GetWindowByViewId(Id view_id) {
     for (std::vector<Window*>::iterator iter = windows_.begin();
          iter != windows_.end();
          ++iter) {
       if ((*iter)->view()->id() == view_id) {
         return iter;
       }
     }
     return windows_.end();
   }
 
   Shell* shell_;
 
   InterfaceFactoryImplWithContext<WindowManagerConnection, WindowManager>
       window_manager_factory_;
 
-  scoped_ptr<mojo::ServiceProvider> debug_panel_;
   Window* launcher_ui_;
   WindowVector windows_;
   ViewManager* view_manager_;
   scoped_ptr<RootLayoutManager> root_layout_manager_;
+  ServiceProviderImpl control_panel_exposed_services_impl_;
 
   scoped_ptr<window_manager::WindowManagerApp> window_manager_app_;
 
   // Id of the view most content is added to.
   Id content_view_id_;
 
   // Id of the debug panel.
   Id control_panel_id_;
 
   GURL url_;
@@ skipping 18 matching lines @@
   window_manager_->RequestNavigate(view_id_, target, request.Pass());
 }
 
 }  // namespace examples
 }  // namespace mojo
 
 MojoResult MojoMain(MojoHandle shell_handle) {
   mojo::ApplicationRunnerChromium runner(new mojo::examples::WindowManager);
   return runner.Run(shell_handle);
 }