Mojo EDK: Add safe process connection API

services/service_manager/README.md

 # Service Manager User Guide
 
 ## What is the Service Manager?
 
 The Service Manager is a tool that brokers connections and capabilities between
 and manages instances of components, referred to henceforth as “services”.
 
 The Service Manager performs the following functions:
 
 * Brokering connections between services, including communicating policies such
@@ skipping 50 matching lines @@
 pair. In Chrome an example of this would be multiple instances of the renderer
 or the same profile.
 
 A Service implements the Mojo interface service_manager.mojom.Service, which is
 the primary means the Service Manager has of communicating with its service.
 Service has two methods: OnStart(), called once at when the Service Manager
 first learns about the service, and OnConnect(), which the Service Manager calls
  every time some other service tries to connect to this one.
 
 Services have a link back to the Service Manager too, primarily in the form of
-the service_manager.mojom.Connector interface. The Connector allows services to 
+the service_manager.mojom.Connector interface. The Connector allows services to
 open connections to other services.
 
 A unique connection from the Service Manager to a service is called an
 “instance,” each with its own unique identifier, called an instance id. Every
 instance has a unique Identity. It is possible to locate an existing instance
 purely using its Identity.
 
 Services define their own lifetimes. Services in processes started by other
 services (rather than the Service Manager) may even outlive the connection with
 the Service Manager. For processes launched by the Service Manager, when a
@@ skipping 51 matching lines @@
     }
 
     service_manifest("manifest") {
       name = "my_service"
       source = "manifest.json"
     }
 
 What does all this do? Building the app target produces two files in the output
 directory: Packages/my_service/my_service.library and
 Packages/my_service/manifest.json. app.library is a DSO loaded by the Service
-Manager in its own process when another service connects to the 
+Manager in its own process when another service connects to the
 service:my_service name. This is not the only way (nor even the most likely one)
  you can implement a Service, but it's the simplest and easiest to reason about.
 
 This service doesn't do much. Its implementation of OnStart() is empty, and its
 implementation of OnConnect just returns true to allow the inbound connection to
 complete. Let's study the parameters to these methods though, since they'll be
 important as we begin to do more in our service.
 
 ##### OnStart Parameters
 
@@ skipping 483 matching lines @@
 
     base::FilePath target_path;
     base::PathService::Get(base::DIR_EXE, &target_path);
     target_path = target_path.Append(FILE_PATH_LITERAL("target.exe"));
     base::CommandLine target_command_line(target_path);
 
     mojo::edk::PlatformChannelPair pair;
     mojo::edk::HandlePassingInformation info;
     pair.PrepareToPassClientHandleToChildProcess(&target_command_line, &info);
 
-    std::string token = mojo::edk::GenerateRandomToken();
+    mojo::edk::PendingProcessConnection connection;
+    std::string token;
+    mojo::ScopedMessagePipeHandle pipe = connection.CreateMessagePipe(&token);
     target_command_line.AppendSwitchASCII(switches::kPrimordialPipeToken,
                                           token);
 
-    mojo::ScopedMessagePipeHandle pipe =
-        mojo::edk::CreateParentMessagePipe(token);
-
-    service_manager::mojom::ServiceFactoryPtr factory;
-    factory.Bind(
-        mojo::InterfacePtrInfo<service_manager::mojom::ServiceFactory>(
-            std::move(pipe), 0u));
+    service_manager::Identity target("exe:target",
+                                     service_manager::mojom::kInheritUserID);
     service_manager::mojom::PIDReceiverPtr receiver;
-
-    service_manager::Identity target("exe:target",service_manager::mojom::kInheritUserID);
-    service_manager::Connector::ConnectParams params(target);
-    params.set_client_process_connection(std::move(factory),
-                                         MakeRequest(&receiver));
-    std::unique_ptr<service_manager::Connection> connection = connector->Connect(&params);
+    connector->RegisterService(target, std::move(pipe), MakeRequest(&receiver));
 
     base::LaunchOptions options;
     options.handles_to_inherit = &info;
     base::Process process = base::LaunchProcess(target_command_line, options);
-    mojo::edk::ChildProcessLaunched(process.Handle(), pair.PassServerHandle());
+    connection.Connect(process.Handle(), pair.PassServerHandle());
 
 That's a lot. But it boils down to these steps:
 1. Creating the message pipe to connect the target process and the Service
 Manager.
 2. Putting the server end of the pipe onto the command line to the target
 process.
 3. Binding the client end to a ServiceFactoryPtr, constructing an Identity for
 the target process and passing both through Connector::Connect().
 4. Starting the process with the configured command line.
 
@@ skipping 123 matching lines @@
 Under the Hood
 Four major components: Service Manager API (Mojom), Service Manager, Catalog,
 Service Manager Client Lib.
 The connect flow, catalog, etc.
 Capability brokering in the Service Manager
 Userids
 
 Finer points:
 
 Service Names: mojo, exe