Service Manager: Implement graceful service termination

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/associated_binding.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_control.mojom.h"
 #include "services/service_manager/public/interfaces/service_manager.mojom.h"
 
 namespace service_manager {
 
 namespace {
 
 const char kCatalogName[] = "service:catalog";
 const char kServiceManagerName[] = "service:service_manager";
 const char kCapability_UserID[] = "service_manager:user_id";
 const char kCapability_ClientProcess[] = "service_manager:client_process";
@@ skipping 29 matching lines @@
   return it->second.find(capability) != it->second.end();
 }
 
 // Encapsulates a connection to an instance of a service, tracked by the
 // Service Manager.
 class ServiceManager::Instance
     : public mojom::Connector,
       public mojom::PIDReceiver,
       public Service,
       public InterfaceFactory<mojom::ServiceManager>,
-      public mojom::ServiceManager {
+      public mojom::ServiceManager,
+      public mojom::ServiceControl {
  public:
   Instance(service_manager::ServiceManager* service_manager,
            const Identity& identity,
            const InterfaceProviderSpecMap& interface_provider_specs)
       : service_manager_(service_manager),
         id_(GenerateUniqueID()),
         identity_(identity),
         interface_provider_specs_(interface_provider_specs),
         allow_any_application_(GetConnectionSpec().requires.count("*") == 1),
         pid_receiver_binding_(this),
+        control_binding_(this),
         state_(State::IDLE),
         weak_factory_(this) {
     if (identity_.name() == kServiceManagerName ||
         identity_.name() == kCatalogName) {
       pid_ = base::Process::Current().Pid();
     }
     DCHECK_NE(mojom::kInvalidInstanceID, id_);
   }
 
   ~Instance() override {
@@ skipping 42 matching lines @@
     std::unique_ptr<ConnectParams> params(std::move(*connect_params));
     if (!params->connect_callback().is_null()) {
         params->connect_callback().Run(mojom::ConnectResult::SUCCEEDED,
                                        identity_.user_id());
     }
 
     InterfaceProviderSpecMap specs;
     Instance* source = service_manager_->GetExistingInstance(params->source());
     if (source)
       specs = source->interface_provider_specs_;
+
+    pending_service_connections_++;
     service_->OnConnect(ServiceInfo(params->source(), specs),
-                        params->TakeRemoteInterfaces());
+                        params->TakeRemoteInterfaces(),
+                        base::Bind(&Instance::OnConnectComplete,
+                                   base::Unretained(this)));
     return true;
   }
 
+  void OnConnectComplete() {
+    DCHECK_GT(pending_service_connections_, 0);
+    pending_service_connections_--;
+  }
+
   void StartWithService(mojom::ServicePtr service) {
     CHECK(!service_);
     state_ = State::STARTING;
     service_ = std::move(service);
     service_.set_connection_error_handler(
         base::Bind(&Instance::OnServiceLost, base::Unretained(this),
                    service_manager_->GetWeakPtr()));
     service_->OnStart(ServiceInfo(identity_, interface_provider_specs_),
-                      base::Bind(&Instance::OnInitializeResponse,
+                      base::Bind(&Instance::OnStartComplete,
                                  base::Unretained(this)));
   }
 
   void StartWithClientProcessConnection(
       mojom::ClientProcessConnectionPtr client_process_connection) {
     mojom::ServicePtr service;
     service.Bind(mojom::ServicePtrInfo(
         std::move(client_process_connection->service), 0));
     pid_receiver_binding_.Bind(
         std::move(client_process_connection->pid_receiver_request));
@@ skipping 226 matching lines @@
     // Any time a Connector is lost or we lose the Service connection, it
     // may have been the last pipe using this Instance. If so, clean up.
     if (service_manager && !service_) {
       if (connectors_.empty())
         service_manager->OnInstanceError(this);
       else
         service_manager->OnInstanceUnreachable(this);
     }
   }
 
-  void OnInitializeResponse(mojom::ConnectorRequest connector_request) {
+  void OnStartComplete(mojom::ConnectorRequest connector_request,
+                       mojom::ServiceControlAssociatedRequest control_request) {
     state_ = State::STARTED;
     if (connector_request.is_pending()) {
       connectors_.AddBinding(this, std::move(connector_request));
       connectors_.set_connection_error_handler(
           base::Bind(&Instance::OnConnectionLost, base::Unretained(this),
                      service_manager_->GetWeakPtr()));
     }
+    if (control_request.is_pending())
+      control_binding_.Bind(std::move(control_request));
     service_manager_->NotifyServiceStarted(identity_, pid_);
   }
 
   // Callback when NativeRunner completes.
   void OnRunnerCompleted() {
     if (!runner_.get())
       return;  // We're in the destructor.
 
     service_manager_->OnInstanceError(this);
   }
 
+  // mojom::ServiceControl:
+  void RequestQuit() override {
+    // If quit is requested, oblige when there are no pending OnConnects.
+    if (!pending_service_connections_)

[blundell, 2016/11/08 14:12:56]

If there are pending service connections, should this remember the quit request
and oblige when there are no more pending connections? It seems a little strange
that the quit request gets silently dropped on the floor in this case.

+      OnServiceLost(service_manager_->GetWeakPtr());
+  }
+
   service_manager::ServiceManager* const service_manager_;
 
   // An id that identifies this instance. Distinct from pid, as a single process
   // may vend multiple application instances, and this object may exist before a
   // process is launched.
   const uint32_t id_;
   Identity identity_;
   const InterfaceProviderSpecMap interface_provider_specs_;
   const InterfaceProviderSpec empty_spec_;
   const bool allow_any_application_;
   std::unique_ptr<NativeRunner> runner_;
   mojom::ServicePtr service_;
   mojo::Binding<mojom::PIDReceiver> pid_receiver_binding_;
   mojo::BindingSet<mojom::Connector> connectors_;
   mojo::BindingSet<mojom::ServiceManager> service_manager_bindings_;
+  mojo::AssociatedBinding<mojom::ServiceControl> control_binding_;
   base::ProcessId pid_ = base::kNullProcessId;
   Instance* parent_ = nullptr;
   InstanceMap children_;
   State state_;
+
+  // The number of outstanding OnConnect requests which are in flight.
+  int pending_service_connections_ = 0;
+
   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 {}
@@ skipping 453 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