[Service Manager] Get rid of dynamic service discovery

services/service_manager/service_manager.h

 // 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.
 
 #ifndef SERVICES_SERVICE_MANAGER_SERVICE_MANAGER_H_
 #define SERVICES_SERVICE_MANAGER_SERVICE_MANAGER_H_
 
 #include <map>
 #include <memory>
 #include <vector>
@@ skipping 54 matching lines @@
   // Provide a callback to be notified whenever an instance is destroyed.
   // Typically the creator of the Service Manager will use this to determine
   // when some set of services it created are destroyed, so it can shut down.
   void SetInstanceQuitCallback(base::Callback<void(const Identity&)> callback);
 
   // Completes a connection between a source and target application as defined
   // by |params|, exchanging InterfaceProviders between them. If no existing
   // instance of the target application is running, one will be loaded.
   void Connect(std::unique_ptr<ConnectParams> params);
 
-  // Creates a new Instance identified as |name|. This is intended for use by
-  // the Service Manager's embedder to register itself. This must only be called
-  // once.
-  mojom::ServiceRequest StartEmbedderService(const std::string& name);
+  // Creates a service instance for |identity|. This is intended for use by the
+  // Service Manager's embedder to register instances directly, without
+  // requiring a Connector.
+  //
+  // |pid_receiver_request| may be null, in which case the service manager
+  // assumes the new service is running in this process.
+  void RegisterService(const Identity& identity,
+                       mojom::ServicePtr service,
+                       mojom::PIDReceiverRequest pid_receiver_request);
 
  private:
   class Instance;
   class ServiceImpl;
 
   void InitCatalog(mojom::ServicePtr catalog);
 
   // Returns the resolver to use for the specified identity.
   // NOTE: Resolvers are cached to ensure we service requests in order. If
   // we use a separate Resolver for each request ordering is not
   // guaranteed and can lead to random flake.
   mojom::Resolver* GetResolver(const Identity& identity);
 
   // Called when |instance| encounters an error. Deletes |instance|.
   void OnInstanceError(Instance* instance);
 
   // Called when |instance| becomes unreachable to new connections because it
   // no longer has any pipes to the ServiceManager.
   void OnInstanceUnreachable(Instance* instance);
 
   // Called by an Instance as it's being destroyed.
   void OnInstanceStopped(const Identity& identity);
 
   // Completes a connection between a source and target application as defined
   // by |params|, exchanging InterfaceProviders between them. If no existing
   // instance of the target application is running, one will be loaded.
   //
-  // If |service| is not null, there must not be an instance of the target
-  // application already running. The Service Manager will create a new instance
-  // and use |service| to control it.
-  //
   // If |instance| is not null, the lifetime of the connection request is
   // bounded by that of |instance|. The connection will be cancelled dropped if
   // |instance| is destroyed.
   void Connect(std::unique_ptr<ConnectParams> params,
-               mojom::ServicePtr service,
                base::WeakPtr<Instance> source_instance);
 
   // Returns a running instance matching |identity|. This might be an instance
   // running as a different user if one is available that services all users.
   Instance* GetExistingInstance(const Identity& identity) const;
 
   // Erases any identities mapping to |instance|. Following this call it is
   // impossible for any call to GetExistingInstance() to return |instance|.
   void EraseInstanceIdentity(Instance* instance);
 
@@ skipping 20 matching lines @@
   mojom::ServiceFactory* GetServiceFactory(
       const Identity& service_factory_identity);
   void OnServiceFactoryLost(const Identity& which);
 
   // Callback when remote Catalog resolves mojo:foo to mojo:bar.
   // |params| are the params passed to Connect().
   // |service| if provided is a ServicePtr which should be used to manage the
   // new application instance. This may be null.
   // |result| contains the result of the resolve operation.
   void OnGotResolvedName(std::unique_ptr<ConnectParams> params,
-                         mojom::ServicePtr service,
                          bool has_source_instance,
                          base::WeakPtr<Instance> source_instance,
                          mojom::ResolveResultPtr result,
                          mojom::ResolveResultPtr parent);
 
   base::WeakPtr<ServiceManager> GetWeakPtr();
 
   std::unique_ptr<ServiceOverrides> service_overrides_;
 
   // Ownership of all Instances.
@@ skipping 22 matching lines @@
   base::WeakPtrFactory<ServiceManager> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(ServiceManager);
 };
 
 mojom::Connector::ConnectCallback EmptyConnectCallback();
 
 }  // namespace service_manager
 
 #endif  // SERVICES_SERVICE_MANAGER_SERVICE_MANAGER_H_