Extract a Connector interface from Shell that can be cloned & passed to other threads

mojo/shell/public/interfaces/shell.mojom

 // 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.
 
 module mojo.shell.mojom;
 
 import "mojo/shell/public/interfaces/interface_provider.mojom";
 
 // Specifies a whitelist of applications and services an application can connect
 // to. Connections to applications not explicitly specified here as a key are
 // rejected. Connections to services not specified in an application's allowed
 // interfaces value are not made.
 // A "*" value as the only key in an otherwise empty map means the application
 // may connect to any other application.
 // A "*" value as the only string in an otherwise empty array of interface names
 // means the application may connect to any service in that application.
 // An empty interface name array means the application may not connect to any
 // services exposed by the application it is connecting to.
 struct CapabilityFilter {
   map<string, array<string>> filter;
 };
 
-// An interface through which a Mojo application may communicate with the Mojo
-// system and request connections to other applications.
-interface Shell {
+// Encapsulates establishing connections with other Mojo applications.
+interface Connector {
   const uint32 kInvalidApplicationID = 0;
   const uint32 kUserRoot = 0;
   const uint32 kUserInherit = 1;
 
   // Requests a connection with another application. The application originating
   // the request is referred to as the "source" and the one receiving the
   // "target".
   //
   // The connection is embodied by a pair of message pipes binding the
   // InterfaceProvider interface, which allows both the source and target
@@ skipping 40 matching lines @@
   //  Response: (application_id)
   //    The shell responds with a unique identifier for the instance that was
   //    connected to.
   //
   Connect(string url,
           uint32 user_id,
           InterfaceProvider&? remote_interfaces,
           InterfaceProvider? local_interfaces,
           CapabilityFilter filter) => (uint32 application_id);
 
+  // Clones this Connector so it can be passed to another thread.
+  Clone(Connector& request);
+};
+
+// Wraps functionality exposed by the Shell to a Mojo application instance.
+interface Shell {
+  // Obtain a Connector that can be used to create connections with other
+  // applications. The connector is bound in the shell to the instance that
+  // vended this Shell interface, all connectors created and cloned frmo this
+  // one are bound to the lifetime of this instance.
+  GetConnector(Connector& connector);
+
   // When there are no more instantiated services in an application, it should
   // start its shutdown process by calling this method. Additionally, it should
   // keep track of any new service requests that come in. The shell will then
   // call Application::OnQuitRequested and start queueing new service requests.
   // If the application didn't get any new service requests in the meantime, it
   // should call the callback with a true value. Otherwise it should call it
   // with false.
   QuitApplication();
 };