Build services as standalone executables

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 172 matching lines @@
   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));
     StartWithService(std::move(service));
   }
 
-  void StartWithFilePath(const base::FilePath& path) {
-    CHECK(!service_);
+  bool StartWithFilePath(const base::FilePath& path) {
+    DCHECK(!service_);
+    DCHECK(!path.empty());
     runner_ = service_manager_->native_runner_factory_->Create(path);
+    if (!runner_)
+      return false;
     bool start_sandboxed = false;
     mojom::ServicePtr service = runner_->Start(
-        path, identity_, start_sandboxed,
+        identity_, start_sandboxed,
         base::Bind(&Instance::PIDAvailable, weak_factory_.GetWeakPtr()),
         base::Bind(&Instance::OnRunnerCompleted, 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 728 matching lines @@
       Identity factory(result->resolved_name, target_user_id,
                        factory_instance_name);
       CreateServiceWithFactory(factory, target.name(), std::move(request));
     } else {
       base::FilePath package_path;
       if (!service_overrides_ || !service_overrides_->GetExecutablePathOverride(
             target.name(), &package_path)) {
         package_path = result->package_path;
       }
 
-      // TODO(rockot): Find a way to block this code path for content but allow
-      // it for chrome_mash.
-      instance->StartWithFilePath(package_path);
+      if (!instance->StartWithFilePath(package_path)) {
+        OnInstanceError(instance);
+        return;
+      }
     }
   }
 
   // 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