chromium/chromecast/external_mojo/external_service_support/external_connector.h

// Copyright 2019 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#ifndef CHROMECAST_EXTERNAL_MOJO_EXTERNAL_SERVICE_SUPPORT_EXTERNAL_CONNECTOR_H_
#define CHROMECAST_EXTERNAL_MOJO_EXTERNAL_SERVICE_SUPPORT_EXTERNAL_CONNECTOR_H_

#include <memory>
#include <string>
#include <utility>
#include <vector>

#include "base/callback_list.h"
#include "chromecast/external_mojo/public/mojom/connector.mojom.h"
#include "mojo/public/cpp/bindings/pending_receiver.h"
#include "mojo/public/cpp/bindings/pending_remote.h"
#include "mojo/public/cpp/system/message_pipe.h"

namespace service_manager {
class Connector;
}  // namespace service_manager

namespace chromecast {
namespace external_service_support {
class ExternalService;

// Interface to the Mojo broker, allowing services to be registered and other
// processes to bind to registered services. Once any public methods are called
// on an instance of this class, that instance is bound to the calling thread.
//
// To use the same interface on another thread, call Clone() and pass the new
// instance to the desired thread before calling any public methods on it.
class ExternalConnector {
 public:
  static void Connect(
      const std::string& broker_path,
      base::OnceCallback<void(std::unique_ptr<ExternalConnector>)> callback);

  static std::unique_ptr<ExternalConnector> Create(
      const std::string& broker_path);

  static std::unique_ptr<ExternalConnector> Create(
      mojo::PendingRemote<external_mojo::mojom::ExternalConnector> remote);

  // Acquires a connector from the BrokerService via the Chromium service
  // manager.
  static std::unique_ptr<ExternalConnector> Create(
      ::service_manager::Connector* connector);

  virtual ~ExternalConnector() = default;

  // Adds a callback that will be called if this class loses its connection to
  // the Mojo broker. The calling class must retain the returned subscription
  // until it intends to unregister. By the time |callback| is executed, a new
  // attempt at connecting will be started, and this object is valid. Note that
  // some prior messages may be lost.
  [[nodiscard]] virtual base::CallbackListSubscription
  AddConnectionErrorCallback(base::RepeatingClosure callback) = 0;

  // Registers a service that other Mojo processes/services can bind to. Others
  // can call BindInterface(|service_name|, interface_name) to bind to this
  // |service|.
  // If registering multiple services, consider using RegisterServices().
  virtual void RegisterService(const std::string& service_name,
                               ExternalService* service) = 0;
  virtual void RegisterService(
      const std::string& service_name,
      mojo::PendingRemote<external_mojo::mojom::ExternalService>
          service_remote) = 0;

  // Registers multiple services that other Mojo processes/services can bind to.
  // Others can call BindInterface(|service_names[i]|, interface_name) to bind
  // to this |service[i]|.
  // This function is more efficient than using multiple times RegisterService()
  // because it only does a single Mojo call.
  virtual void RegisterServices(
      const std::vector<std::string>& service_names,
      const std::vector<ExternalService*>& services) = 0;
  virtual void RegisterServices(
      std::vector<chromecast::external_mojo::mojom::ServiceInstanceInfoPtr>
          service_instances_info) = 0;

  // Asks the Mojo broker to bind to a matching interface on the service with
  // the given |service_name|. If the service does not yet exist, the binding
  // will remain in progress until the service is registered. If |async| is
  // |false|, then the bind will execute synchronously; otherwise, it will
  // execute asynchronously on the same sequence (see b/146508043).
  template <typename Interface>
  void BindInterface(const std::string& service_name,
                     mojo::PendingReceiver<Interface> receiver,
                     bool async = true) {
    BindInterface(service_name, Interface::Name_, receiver.PassPipe(), async);
  }

  virtual void BindInterface(const std::string& service_name,
                             const std::string& interface_name,
                             mojo::ScopedMessagePipeHandle interface_pipe,
                             bool async = true) = 0;

  // Creates a new instance of this class which may be passed to another thread.
  // The returned object may be passed across sequences until any of its public
  // methods are called, at which point it becomes bound to the calling
  // sequence.
  virtual std::unique_ptr<ExternalConnector> Clone() = 0;

  // Requests a PendingRemote for an ExternalConnector which can be passed to a
  // different process.
  virtual mojo::PendingRemote<external_mojo::mojom::ExternalConnector>
  RequestConnector() = 0;

  // Sends a request for a Chromium ServiceManager connector.
  virtual void SendChromiumConnectorRequest(
      mojo::ScopedMessagePipeHandle request) = 0;

  // Query the list of available services from this connector.
  virtual void QueryServiceList(
      base::OnceCallback<
          void(std::vector<
               chromecast::external_mojo::mojom::ExternalServiceInfoPtr>)>
          callback) = 0;
};

}  // namespace external_service_support
}  // namespace chromecast

#endif  // CHROMECAST_EXTERNAL_MOJO_EXTERNAL_SERVICE_SUPPORT_EXTERNAL_CONNECTOR_H_