Service Manager: Rework Service and ServiceContext lifetime

services/service_manager/tests/lifecycle/package.cc

Index: services/service_manager/tests/lifecycle/package.cc
diff --git a/services/service_manager/tests/lifecycle/package.cc b/services/service_manager/tests/lifecycle/package.cc
index 25dc8a1c8e2a8595a39bd4e4a062b72130ca831a..1be7d9353a3a6f3cccc487d232110f0940867c47 100644
--- a/services/service_manager/tests/lifecycle/package.cc
+++ b/services/service_manager/tests/lifecycle/package.cc
@@ -7,8 +7,11 @@
 
 #include "base/bind.h"
 #include "base/macros.h"
+#include "base/memory/ptr_util.h"
 #include "mojo/public/cpp/bindings/binding_set.h"
 #include "services/service_manager/public/c/main.h"
+#include "services/service_manager/public/cpp/interface_factory.h"
+#include "services/service_manager/public/cpp/interface_registry.h"
 #include "services/service_manager/public/cpp/service_context.h"
 #include "services/service_manager/public/cpp/service_runner.h"
 #include "services/service_manager/public/interfaces/service_factory.mojom.h"
@@ -17,39 +20,41 @@
 
 namespace {
 
-class PackagedApp : public service_manager::Service,
-                    public service_manager::InterfaceFactory<LifecycleControl>,
-                    public LifecycleControl {
+class PackagedApp
+    : public service_manager::Service,
+      public service_manager::InterfaceFactory<
+          service_manager::test::mojom::LifecycleControl>,
+      public service_manager::test::mojom::LifecycleControl {
  public:
-  using DestructCallback = base::Callback<void(PackagedApp*)>;
-
   PackagedApp(
-      service_manager::mojom::ServiceRequest request,
-      const DestructCallback& service_manager_connection_closed_callback,
-      const DestructCallback& destruct_callback)
-      : connection_(
-            new service_manager::ServiceContext(this, std::move(request))),
-        service_manager_connection_closed_callback_(
+      const base::Closure& service_manager_connection_closed_callback,
+      const base::Closure& destruct_callback)
+      : service_manager_connection_closed_callback_(
             service_manager_connection_closed_callback),
         destruct_callback_(destruct_callback) {
     bindings_.set_connection_error_handler(base::Bind(&PackagedApp::BindingLost,
                                                       base::Unretained(this)));
   }
-  ~PackagedApp() override {
-    destruct_callback_.Run(this);
-  }
+
+  ~PackagedApp() override {}
 
  private:
   // service_manager::Service:
+  void OnStart(service_manager::ServiceContext* context) override {
+    context_ = context;
+  }
+
   bool OnConnect(const service_manager::ServiceInfo& remote_info,
                  service_manager::InterfaceRegistry* registry) override {
-    registry->AddInterface<LifecycleControl>(this);
+    registry->AddInterface<service_manager::test::mojom::LifecycleControl>(
+        this);
     return true;
   }
 
   // service_manager::InterfaceFactory<LifecycleControl>
-  void Create(const service_manager::Identity& remote_identity,
-              LifecycleControlRequest request) override {
+  void Create(
+      const service_manager::Identity& remote_identity,
+      service_manager::test::mojom::LifecycleControlRequest request) override {
     bindings_.AddBinding(this, std::move(request));
   }
 
@@ -57,35 +62,42 @@ class PackagedApp : public service_manager::Service,
   void Ping(const PingCallback& callback) override {
     callback.Run();
   }
+
   void GracefulQuit() override {
-    service_manager_connection_closed_callback_.Run(this);
-    delete this;
-    // This will have closed all |bindings_|.
+    service_manager_connection_closed_callback_.Run();
+
+    // Deletes |this|.
+    destruct_callback_.Run();
   }
+
   void Crash() override {
     // When multiple instances are vended from the same package instance, this
     // will cause all instances to be quit.
     exit(1);
   }
+
   void CloseServiceManagerConnection() override {
-    service_manager_connection_closed_callback_.Run(this);
-    connection_.reset();
+    service_manager_connection_closed_callback_.Run();
+    context_->QuitNow();
     // This only closed our relationship with the service manager, existing
     // |bindings_|
     // remain active.
   }
 
   void BindingLost() {
-    if (bindings_.empty())
-      delete this;
+    if (bindings_.empty()) {
+      // Deletes |this|.
+      destruct_callback_.Run();
+    }
   }
 
-  std::unique_ptr<service_manager::ServiceContext> connection_;
-  mojo::BindingSet<LifecycleControl> bindings_;
+  service_manager::ServiceContext* context_;
+  mojo::BindingSet<service_manager::test::mojom::LifecycleControl> bindings_;
+
   // Run when this object's connection to the service manager is closed.
-  DestructCallback service_manager_connection_closed_callback_;
+  base::Closure service_manager_connection_closed_callback_;
   // Run when this object is destructed.
-  DestructCallback destruct_callback_;
+  base::Closure destruct_callback_;
 
   DISALLOW_COPY_AND_ASSIGN(PackagedApp);
 };
@@ -98,12 +110,12 @@ class Package : public service_manager::Service,
   Package() {}
   ~Package() override {}
 
-  void set_runner(service_manager::ServiceRunner* runner) {
-    app_client_.set_runner(runner);
+ private:
+  // service_manager::Service:
+  void OnStart(service_manager::ServiceContext* context) override {
+    app_client_.OnStart(context);
   }
 
- private:
-  // service_manager::test::AppClient:
   bool OnConnect(const service_manager::ServiceInfo& remote_info,
                  service_manager::InterfaceRegistry* registry) override {
     registry->AddInterface<service_manager::mojom::ServiceFactory>(this);
@@ -120,30 +132,48 @@ class Package : public service_manager::Service,
   void CreateService(service_manager::mojom::ServiceRequest request,
                      const std::string& name) override {
     ++service_manager_connection_refcount_;
-    apps_.push_back(new PackagedApp(
-        std::move(request),
-        base::Bind(&Package::AppServiceManagerConnectionClosed,
-                   base::Unretained(this)),
-        base::Bind(&Package::AppDestructed, base::Unretained(this))));
+    int id = next_id_++;
+    std::unique_ptr<service_manager::ServiceContext> context =
+        base::MakeUnique<service_manager::ServiceContext>(
+            base::MakeUnique<PackagedApp>(
+                base::Bind(&Package::AppServiceManagerConnectionClosed,
+                           base::Unretained(this)),
+                base::Bind(&Package::DestroyService, base::Unretained(this),
+                           id)),
+            std::move(request));
+    service_manager::ServiceContext* raw_context = context.get();
+    contexts_.insert(std::make_pair(raw_context, std::move(context)));
+    id_to_context_.insert(std::make_pair(id, raw_context));
   }
 
-  void AppServiceManagerConnectionClosed(PackagedApp* app) {
+  void AppServiceManagerConnectionClosed() {
     if (!--service_manager_connection_refcount_)
       app_client_.CloseServiceManagerConnection();
   }
 
-  void AppDestructed(PackagedApp* app) {
-    auto it = std::find(apps_.begin(), apps_.end(), app);
-    DCHECK(it != apps_.end());
-    apps_.erase(it);
-    if (apps_.empty() && base::MessageLoop::current()->is_running())
+  void DestroyService(int id) {
+    auto id_it = id_to_context_.find(id);
+    DCHECK(id_it != id_to_context_.end());
+
+    auto it = contexts_.find(id_it->second);
+    DCHECK(it != contexts_.end());
+    contexts_.erase(it);
+    id_to_context_.erase(id_it);
+    if (contexts_.empty() && base::MessageLoop::current()->is_running())
       base::MessageLoop::current()->QuitWhenIdle();
   }
 
   service_manager::test::AppClient app_client_;
   int service_manager_connection_refcount_ = 0;
   mojo::BindingSet<service_manager::mojom::ServiceFactory> bindings_;
-  std::vector<PackagedApp*> apps_;
+
+  using ServiceContextMap =
+      std::map<service_manager::ServiceContext*,
+               std::unique_ptr<service_manager::ServiceContext>>;
+  ServiceContextMap contexts_;
+
+  int next_id_ = 0;
+  std::map<int, service_manager::ServiceContext*> id_to_context_;
 
   DISALLOW_COPY_AND_ASSIGN(Package);
 };
@@ -151,8 +181,6 @@ class Package : public service_manager::Service,
 }  // namespace
 
 MojoResult ServiceMain(MojoHandle service_request_handle) {
-  Package* package = new Package;
-  service_manager::ServiceRunner runner(package);
-  package->set_runner(&runner);
+  service_manager::ServiceRunner runner(new Package);
   return runner.Run(service_request_handle);
 }