Service Manager: Rework Service and ServiceContext lifetime

services/service_manager/service_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 "services/service_manager/service_manager.h"
 
 #include <stdint.h>
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/debug/alias.h"
 #include "base/guid.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/process/process.h"
 #include "base/process/process_handle.h"
 #include "base/stl_util.h"
 #include "base/strings/string_util.h"
 #include "base/trace_event/trace_event.h"
 #include "mojo/public/cpp/bindings/binding.h"
 #include "mojo/public/cpp/bindings/binding_set.h"
 #include "services/service_manager/connect_util.h"
 #include "services/service_manager/public/cpp/connector.h"
+#include "services/service_manager/public/cpp/interface_registry.h"
 #include "services/service_manager/public/cpp/names.h"
+#include "services/service_manager/public/cpp/service.h"
 #include "services/service_manager/public/cpp/service_context.h"
 #include "services/service_manager/public/interfaces/connector.mojom.h"
 #include "services/service_manager/public/interfaces/service.mojom.h"
 #include "services/service_manager/public/interfaces/service_manager.mojom.h"
 
 namespace service_manager {
 
 namespace {
 
 const char kCatalogName[] = "service:catalog";
@@ skipping 408 matching lines @@
   mojo::BindingSet<mojom::ServiceManager> service_manager_bindings_;
   base::ProcessId pid_ = base::kNullProcessId;
   Instance* parent_ = nullptr;
   InstanceMap children_;
   State state_;
   base::WeakPtrFactory<Instance> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(Instance);
 };
 
+class ServiceManager::ServiceImpl : public Service {
+ public:
+  explicit ServiceImpl(ServiceManager* service_manager)
+      : service_manager_(service_manager) {}
+  ~ServiceImpl() override {}
+
+  // Service:
+  bool OnConnect(const ServiceInfo& remote_info,
+                 InterfaceRegistry* registry) override {
+    // The only interface ServiceManager exposes is mojom::ServiceManager, and
+    // access to this interface is brokered by a policy specific to each caller,
+    // managed by the caller's instance. Here we look to see who's calling,
+    // and forward to the caller's instance to continue.
+    Instance* instance = nullptr;
+    for (const auto& entry : service_manager_->identity_to_instance_) {
+      if (entry.first == remote_info.identity) {
+        instance = entry.second;
+        break;
+      }
+    }
+
+    DCHECK(instance);
+    return instance->OnConnect(remote_info, registry);
+  }
+
+ private:
+  ServiceManager* const service_manager_;
+
+  DISALLOW_COPY_AND_ASSIGN(ServiceImpl);
+};
+
 // static
 ServiceManager::TestAPI::TestAPI(ServiceManager* service_manager)
     : service_manager_(service_manager) {}
 ServiceManager::TestAPI::~TestAPI() {}
 
 bool ServiceManager::TestAPI::HasRunningInstanceForName(
     const std::string& name) const {
   for (const auto& entry : service_manager_->identity_to_instance_) {
     if (entry.first.name() == name)
       return true;
@@ skipping 18 matching lines @@
   spec.requires["*"].insert("service_manager:service_factory");
   spec.requires["service:catalog"].insert("service_manager:resolver");
   spec.requires["service:tracing"].insert("app");
   InterfaceProviderSpecMap specs;
   specs[mojom::kServiceManager_ConnectorSpec] = spec;
 
   service_manager_instance_ =
       CreateInstance(Identity(), CreateServiceManagerIdentity(), specs);
   service_manager_instance_->StartWithService(std::move(service));
   singletons_.insert(kServiceManagerName);
-  service_context_.reset(new ServiceContext(this, std::move(request)));
+  service_context_.reset(new ServiceContext(
+      base::MakeUnique<ServiceImpl>(this), std::move(request)));
 
   if (catalog)
     InitCatalog(std::move(catalog));
 }
 
 ServiceManager::~ServiceManager() {
   // Ensure we tear down the ServiceManager instance last. This is to avoid
   // hitting bindings DCHECKs, since the ServiceManager or Catalog may at any
   // given time own in-flight responders for Instances' Connector requests.
   std::unique_ptr<Instance> service_manager_instance;
@@ skipping 27 matching lines @@
   params->set_target(embedder_identity);
 
   mojom::ServicePtr service;
   mojom::ServiceRequest request = mojo::GetProxy(&service);
   Connect(std::move(params), std::move(service), nullptr);
 
   return request;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-// ServiceManager, Service implementation:
-
-bool ServiceManager::OnConnect(const ServiceInfo& remote_info,
-                               InterfaceRegistry* registry) {
-  // The only interface we expose is mojom::ServiceManager, and access to this
-  // interface is brokered by a policy specific to each caller, managed by the
-  // caller's instance. Here we look to see who's calling, and forward to the
-  // caller's instance to continue.
-  Instance* instance = nullptr;
-  for (const auto& entry : identity_to_instance_) {
-    if (entry.first == remote_info.identity) {
-      instance = entry.second;
-      break;
-    }
-  }
-  DCHECK(instance);
-  return instance->OnConnect(remote_info, registry);
-}
-
-////////////////////////////////////////////////////////////////////////////////
 // ServiceManager, private:
 
 void ServiceManager::InitCatalog(mojom::ServicePtr catalog) {
   // TODO(beng): It'd be great to build this from the manifest, however there's
   //             a bit of a chicken-and-egg problem.
   InterfaceProviderSpec spec;
   spec.provides["app"].insert("filesystem::mojom::Directory");
   spec.provides["catalog:catalog"].insert("catalog::mojom::Catalog");
   spec.provides["service_manager:resolver"].insert(
       "service_manager::mojom::Resolver");
@@ skipping 330 matching lines @@
   // Now that the instance has a Service, we can connect to it.
   bool connected = instance->ConnectToService(&params);
   DCHECK(connected);
 }
 
 base::WeakPtr<ServiceManager> ServiceManager::GetWeakPtr() {
   return weak_ptr_factory_.GetWeakPtr();
 }
 
 }  // namespace service_manager