Consolidating the mojo NativeRunner functionality.

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>
 
@@ skipping 100 matching lines @@
     connectors_.CloseAllBindings();
     service_manager_bindings_.CloseAllBindings();
     service_manager_->OnInstanceUnreachable(this);
 
     if (state_ == State::STARTING) {
       service_manager_->NotifyServiceFailedToStart(identity_);
     } else {
       // Notify the ServiceManager that this Instance is really going away.
       service_manager_->OnInstanceStopped(identity_);
     }
-
-    // Release |runner_| so that if we are called back to OnRunnerCompleted()
-    // we know we're in the destructor.
-    std::unique_ptr<NativeRunner> runner = std::move(runner_);
-    runner.reset();
   }
 
   Instance* parent() const { return parent_; }
 
   void AddChild(std::unique_ptr<Instance> child) {
     child->parent_ = this;
     children_.insert(std::make_pair(child.get(), std::move(child)));
   }
 
   void RemoveChild(Instance* child) {
@@ skipping 50 matching lines @@
     service.Bind(mojom::ServicePtrInfo(
         std::move(client_process_connection->service), 0));
     pid_receiver_binding_.Bind(
         std::move(client_process_connection->pid_receiver_request));
     StartWithService(std::move(service));
   }
 
   bool StartWithFilePath(const base::FilePath& path) {
     DCHECK(!service_);
     DCHECK(!path.empty());
-    runner_ = service_manager_->native_runner_factory_->Create(path);
+    runner_ = service_manager_->service_process_launcher_factory_->Create(path);
     if (!runner_)
       return false;
     bool start_sandboxed = false;
     mojom::ServicePtr service = runner_->Start(
         identity_, start_sandboxed,
-        base::Bind(&Instance::PIDAvailable, weak_factory_.GetWeakPtr()),
-        base::Bind(&Instance::OnRunnerCompleted, weak_factory_.GetWeakPtr()));
+        base::Bind(&Instance::PIDAvailable, weak_factory_.GetWeakPtr()));
     StartWithService(std::move(service));
     return true;
   }
 
   mojom::RunningServiceInfoPtr CreateRunningServiceInfo() const {
     mojom::RunningServiceInfoPtr info(mojom::RunningServiceInfo::New());
     info->id = id_;
     info->identity = identity_;
     info->pid = pid_;
     return info;
@@ skipping 220 matching lines @@
       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_)
       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_;
+  std::unique_ptr<ServiceProcessLauncher> 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_;
 
@@ skipping 47 matching lines @@
     if (entry.first.name() == name)
       return true;
   }
   return false;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // ServiceManager, public:
 
 ServiceManager::ServiceManager(
-    std::unique_ptr<NativeRunnerFactory> native_runner_factory,
+    std::unique_ptr<ServiceProcessLauncherFactory>
+        service_process_launcher_factory,
     mojom::ServicePtr catalog)
-    : native_runner_factory_(std::move(native_runner_factory)),
+    : service_process_launcher_factory_(
+          std::move(service_process_launcher_factory)),
       weak_ptr_factory_(this) {
   mojom::ServicePtr service;
   mojom::ServiceRequest request = mojo::GetProxy(&service);
 
   InterfaceProviderSpec spec;
   spec.provides[kCapability_ServiceManager].insert(
       "service_manager::mojom::ServiceManager");
   spec.requires["*"].insert("service_manager:service_factory");
   spec.requires[catalog::mojom::kServiceName].insert(
       "service_manager:resolver");
@@ skipping 411 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