Add RegisterService, split out of Connect().
- Eliminates client lib's ConnectParams struct as this is no longer needed.
- Converts call sites.
- In Service Manager, RegisterService just calls Connect() with some empty values. The codepath is mostly the same. Note that when the ClientProcessConnection is passed now OnGotResolvedName returns early prior to completing the connection, as RegisterService is not a "connect" action, just a "start" one.
[email protected],[email protected]
Review-Url: https://codereview.chromium.org/2610173003
Cr-Commit-Position: refs/heads/master@{#442114}
diff --git a/chrome/test/base/mojo_test_connector.cc b/chrome/test/base/mojo_test_connector.cc
index ef0effc..34135f4 100644
--- a/chrome/test/base/mojo_test_connector.cc
+++ b/chrome/test/base/mojo_test_connector.cc
@@ -74,15 +74,8 @@
// will spawn a new instance.
params->set_target(service_manager::Identity(
kTestName, service_manager::mojom::kRootUserID));
-
- service_manager::mojom::ClientProcessConnectionPtr
- client_process_connection =
- service_manager::mojom::ClientProcessConnection::New();
- client_process_connection->service =
- service.PassInterface().PassHandle();
- client_process_connection->pid_receiver_request =
- mojo::MakeRequest(&pid_receiver_).PassMessagePipe();
- params->set_client_process_connection(std::move(client_process_connection));
+ params->set_client_process_info(std::move(service),
+ MakeRequest(&pid_receiver_));
service_manager->Connect(std::move(params));
}
diff --git a/content/browser/browser_context.cc b/content/browser/browser_context.cc
index b287a6c..a5728e2 100644
--- a/content/browser/browser_context.cc
+++ b/content/browser/browser_context.cc
@@ -439,15 +439,14 @@
service_manager::mojom::ServiceRequest service_request(&service);
service_manager::mojom::PIDReceiverPtr pid_receiver;
- service_manager::Connector::ConnectParams params(
- service_manager::Identity(mojom::kBrowserServiceName, new_id));
- params.set_client_process_connection(std::move(service),
- mojo::MakeRequest(&pid_receiver));
+ service_manager::Identity identity(mojom::kBrowserServiceName, new_id);
+ service_manager_connection->GetConnector()->Start(
+ identity, std::move(service), mojo::MakeRequest(&pid_receiver));
pid_receiver->SetPID(base::GetCurrentProcId());
BrowserContextServiceManagerConnectionHolder* connection_holder =
new BrowserContextServiceManagerConnectionHolder(
- service_manager_connection->GetConnector()->Connect(¶ms),
+ service_manager_connection->GetConnector()->Connect(identity),
std::move(service_request));
browser_context->SetUserData(kServiceManagerConnection, connection_holder);
diff --git a/content/common/service_manager/child_connection.cc b/content/common/service_manager/child_connection.cc
index d86117f..68d4466 100644
--- a/content/common/service_manager/child_connection.cc
+++ b/content/common/service_manager/child_connection.cc
@@ -94,13 +94,12 @@
service_manager::mojom::PIDReceiverRequest pid_receiver_request(
&pid_receiver_);
- service_manager::Connector::ConnectParams params(child_identity);
- params.set_client_process_connection(std::move(service),
- std::move(pid_receiver_request));
-
- // In some unit testing scenarios a null connector is passed.
- if (connector)
- connection_ = connector->Connect(¶ms);
+ if (connector) {
+ connector->Start(child_identity,
+ std::move(service),
+ std::move(pid_receiver_request));
+ connection_ = connector->Connect(child_identity);
+ }
}
void ShutDownOnIOThread() {
diff --git a/services/service_manager/connect_params.h b/services/service_manager/connect_params.h
index 102e28d..a2104cd 100644
--- a/services/service_manager/connect_params.h
+++ b/services/service_manager/connect_params.h
@@ -13,6 +13,7 @@
#include "services/service_manager/public/cpp/identity.h"
#include "services/service_manager/public/interfaces/connector.mojom.h"
#include "services/service_manager/public/interfaces/interface_provider.mojom.h"
+#include "services/service_manager/public/interfaces/service.mojom.h"
namespace service_manager {
@@ -35,12 +36,20 @@
return std::move(remote_interfaces_);
}
- void set_client_process_connection(
- mojom::ClientProcessConnectionPtr client_process_connection) {
- client_process_connection_ = std::move(client_process_connection);
+ void set_client_process_info(
+ mojom::ServicePtr service,
+ mojom::PIDReceiverRequest pid_receiver_request) {
+ service_ = std::move(service);
+ pid_receiver_request_ = std::move(pid_receiver_request);
}
- mojom::ClientProcessConnectionPtr TakeClientProcessConnection() {
- return std::move(client_process_connection_);
+ bool HasClientProcessInfo() const {
+ return service_.is_bound() && pid_receiver_request_.is_pending();
+ }
+ mojom::ServicePtr TakeService() {
+ return std::move(service_);
+ }
+ mojom::PIDReceiverRequest TakePIDReceiverRequest() {
+ return std::move(pid_receiver_request_);
}
void set_connect_callback(const mojom::Connector::ConnectCallback& value) {
@@ -58,7 +67,8 @@
Identity target_;
mojom::InterfaceProviderRequest remote_interfaces_;
- mojom::ClientProcessConnectionPtr client_process_connection_;
+ mojom::ServicePtr service_;
+ mojom::PIDReceiverRequest pid_receiver_request_;
mojom::Connector::ConnectCallback connect_callback_;
DISALLOW_COPY_AND_ASSIGN(ConnectParams);
diff --git a/services/service_manager/public/cpp/connector.h b/services/service_manager/public/cpp/connector.h
index 5251b26f..73560d3e 100644
--- a/services/service_manager/public/cpp/connector.h
+++ b/services/service_manager/public/cpp/connector.h
@@ -36,73 +36,39 @@
public:
virtual ~Connector() {}
- class ConnectParams {
- public:
- explicit ConnectParams(const Identity& target);
- explicit ConnectParams(const std::string& name);
- ~ConnectParams();
-
- const Identity& target() { return target_; }
- void set_target(const Identity& target) { target_ = target; }
- void set_client_process_connection(
- mojom::ServicePtr service,
- mojom::PIDReceiverRequest pid_receiver_request) {
- service_ = std::move(service);
- pid_receiver_request_ = std::move(pid_receiver_request);
- }
- void TakeClientProcessConnection(
- mojom::ServicePtr* service,
- mojom::PIDReceiverRequest* pid_receiver_request) {
- *service = std::move(service_);
- *pid_receiver_request = std::move(pid_receiver_request_);
- }
- InterfaceProvider* remote_interfaces() { return remote_interfaces_; }
- void set_remote_interfaces(InterfaceProvider* remote_interfaces) {
- remote_interfaces_ = remote_interfaces;
- }
-
- private:
- Identity target_;
- mojom::ServicePtr service_;
- mojom::PIDReceiverRequest pid_receiver_request_;
- InterfaceProvider* remote_interfaces_ = nullptr;
-
- DISALLOW_COPY_AND_ASSIGN(ConnectParams);
- };
-
// Creates a new Connector instance and fills in |*request| with a request
// for the other end the Connector's interface.
static std::unique_ptr<Connector> Create(mojom::ConnectorRequest* request);
- // Requests a new connection to an application. Returns a pointer to the
- // connection if the connection is permitted by this application's delegate,
- // or nullptr otherwise. Caller takes ownership.
- // Once this method is called, this object is bound to the thread on which the
- // call took place. To pass to another thread, call Clone() and pass the
- // result.
- virtual std::unique_ptr<Connection> Connect(const std::string& name) = 0;
- virtual std::unique_ptr<Connection> Connect(ConnectParams* params) = 0;
+ // Creates an instance of a service for |identity| in a process started by the
+ // client (or someone else). Must be called before Connect() may be called to
+ // |identity|.
+ virtual void Start(
+ const Identity& identity,
+ mojom::ServicePtr service,
+ mojom::PIDReceiverRequest pid_receiver_request) = 0;
- // Connect to application identified by |request->name| and connect to the
- // service implementation of the interface identified by |Interface|.
+ // Requests a new connection to a service. Returns a pointer to the
+ // connection if the connection is permitted by that service, nullptr
+ // otherwise. Once this method is called, this object is bound to the thread
+ // on which the call took place. To pass to another thread, call Clone() and
+ // pass the result.
+ virtual std::unique_ptr<Connection> Connect(const std::string& name) = 0;
+ virtual std::unique_ptr<Connection> Connect(const Identity& target) = 0;
+
+ // Connect to |target| & request to bind |Interface|. Does not retain a
+ // connection to |target|.
template <typename Interface>
- void ConnectToInterface(ConnectParams* params,
+ void ConnectToInterface(const Identity& target,
mojo::InterfacePtr<Interface>* ptr) {
- std::unique_ptr<Connection> connection = Connect(params);
+ std::unique_ptr<Connection> connection = Connect(target);
if (connection)
connection->GetInterface(ptr);
}
template <typename Interface>
- void ConnectToInterface(const Identity& target,
- mojo::InterfacePtr<Interface>* ptr) {
- ConnectParams params(target);
- return ConnectToInterface(¶ms, ptr);
- }
- template <typename Interface>
void ConnectToInterface(const std::string& name,
mojo::InterfacePtr<Interface>* ptr) {
- ConnectParams params(name);
- return ConnectToInterface(¶ms, ptr);
+ return ConnectToInterface(Identity(name, mojom::kInheritUserID), ptr);
}
// Creates a new instance of this class which may be passed to another thread.
diff --git a/services/service_manager/public/cpp/lib/connector_impl.cc b/services/service_manager/public/cpp/lib/connector_impl.cc
index 9d66a1cf..ab30195b 100644
--- a/services/service_manager/public/cpp/lib/connector_impl.cc
+++ b/services/service_manager/public/cpp/lib/connector_impl.cc
@@ -10,14 +10,6 @@
namespace service_manager {
-Connector::ConnectParams::ConnectParams(const Identity& target)
- : target_(target) {}
-
-Connector::ConnectParams::ConnectParams(const std::string& name)
- : target_(name, mojom::kInheritUserID) {}
-
-Connector::ConnectParams::~ConnectParams() {}
-
ConnectorImpl::ConnectorImpl(mojom::ConnectorPtrInfo unbound_state)
: unbound_state_(std::move(unbound_state)) {
thread_checker_.DetachFromThread();
@@ -36,50 +28,39 @@
connector_.reset();
}
-std::unique_ptr<Connection> ConnectorImpl::Connect(const std::string& name) {
- ConnectParams params(name);
- return Connect(¶ms);
+void ConnectorImpl::Start(
+ const Identity& identity,
+ mojom::ServicePtr service,
+ mojom::PIDReceiverRequest pid_receiver_request) {
+ if (!BindIfNecessary())
+ return;
+
+ DCHECK(service.is_bound() && pid_receiver_request.is_pending());
+ connector_->Start(identity,
+ service.PassInterface().PassHandle(),
+ std::move(pid_receiver_request));
}
-std::unique_ptr<Connection> ConnectorImpl::Connect(ConnectParams* params) {
+std::unique_ptr<Connection> ConnectorImpl::Connect(const std::string& name) {
+ return Connect(Identity(name, mojom::kInheritUserID));
+}
+
+std::unique_ptr<Connection> ConnectorImpl::Connect(const Identity& target) {
if (!BindIfNecessary())
return nullptr;
DCHECK(thread_checker_.CalledOnValidThread());
- DCHECK(params);
mojom::InterfaceProviderPtr remote_interfaces;
mojom::InterfaceProviderRequest remote_request(&remote_interfaces);
std::unique_ptr<internal::ConnectionImpl> connection(
- new internal::ConnectionImpl(params->target(),
- Connection::State::PENDING));
- if (params->remote_interfaces()) {
- params->remote_interfaces()->Bind(std::move(remote_interfaces));
- connection->set_remote_interfaces(params->remote_interfaces());
- } else {
- std::unique_ptr<InterfaceProvider> remote_interface_provider(
- new InterfaceProvider);
- remote_interface_provider->Bind(std::move(remote_interfaces));
- connection->SetRemoteInterfaces(std::move(remote_interface_provider));
- }
+ new internal::ConnectionImpl(target, Connection::State::PENDING));
+ std::unique_ptr<InterfaceProvider> remote_interface_provider(
+ new InterfaceProvider);
+ remote_interface_provider->Bind(std::move(remote_interfaces));
+ connection->SetRemoteInterfaces(std::move(remote_interface_provider));
- mojom::ServicePtr service;
- mojom::PIDReceiverRequest pid_receiver_request;
- params->TakeClientProcessConnection(&service, &pid_receiver_request);
- mojom::ClientProcessConnectionPtr client_process_connection;
- if (service.is_bound() && pid_receiver_request.is_pending()) {
- client_process_connection = mojom::ClientProcessConnection::New();
- client_process_connection->service =
- service.PassInterface().PassHandle();
- client_process_connection->pid_receiver_request =
- pid_receiver_request.PassMessagePipe();
- } else if (service.is_bound() || pid_receiver_request.is_pending()) {
- NOTREACHED() << "If one of service or pid_receiver_request is valid, "
- << "both must be valid.";
- return std::move(connection);
- }
- connector_->Connect(params->target(), std::move(remote_request),
- std::move(client_process_connection),
+ connector_->Connect(target, std::move(remote_request),
connection->GetConnectCallback());
return std::move(connection);
}
diff --git a/services/service_manager/public/cpp/lib/connector_impl.h b/services/service_manager/public/cpp/lib/connector_impl.h
index a07858c..14a1d77 100644
--- a/services/service_manager/public/cpp/lib/connector_impl.h
+++ b/services/service_manager/public/cpp/lib/connector_impl.h
@@ -24,8 +24,11 @@
void OnConnectionError();
// Connector:
+ void Start(const Identity& identity,
+ mojom::ServicePtr service,
+ mojom::PIDReceiverRequest pid_receiver_request) override;
std::unique_ptr<Connection> Connect(const std::string& name) override;
- std::unique_ptr<Connection> Connect(ConnectParams* params) override;
+ std::unique_ptr<Connection> Connect(const Identity& target) override;
std::unique_ptr<Connector> Clone() override;
void BindRequest(mojom::ConnectorRequest request) override;
diff --git a/services/service_manager/public/interfaces/connector.mojom b/services/service_manager/public/interfaces/connector.mojom
index b1e7314..bff2cf0 100644
--- a/services/service_manager/public/interfaces/connector.mojom
+++ b/services/service_manager/public/interfaces/connector.mojom
@@ -67,26 +67,31 @@
SetPID(uint32 pid);
};
-// Typically, the service manager will start a process for a service the first
-// time it receives a connection request for it. This struct allows a client to
-// start the process itself and provide the service manager the pipes it needs
-// to communicate with it. When an instance of this struct is supplied to
-// Connect(), the client owns the lifetime of the child process, not the service
-// manager. The service manager binds the |service| pipe, and when it closes
-// destroys the associated instance but the process stays alive.
-struct ClientProcessConnection {
- // Provides the service manager the ability to bind a Service from the client
- // process to the instance it creates.
- handle<message_pipe> service;
-
- // Allows the client process launcher to tell the service manager the PID of
- // the process it created (the pid isn't supplied directly here as the process
- // may not have been launched by the time Connect() is called.)
- handle<message_pipe> pid_receiver_request;
-};
-
// Encapsulates establishing connections with other Services.
interface Connector {
+ // Typically, the service manager will start a process for a service the first
+ // time it receives a connection request for it. This struct allows a client
+ // to start the process itself and provide the service manager the pipes it
+ // needs to communicate with it. When this function is called, the client owns
+ // the lifetime of the child process it started, not the service manager. The
+ // service manager binds the |service| pipe, and when it closes destroys the
+ // associated instance but the process stays alive.
+ //
+ // Parameters:
+ //
+ // service
+ // A pipe to an implementation of Service that the service manager can use
+ // to communicate with the service.
+ //
+ // pid_receiver_request
+ // Allows the client process launcher to tell the service manager the PID of
+ // the process it created (the pid isn't supplied directly here as the
+ // process may not have been launched by the time Connect() is called.)
+ //
+ Start(Identity name,
+ handle<message_pipe> service,
+ PIDReceiver& pid_receiver_request);
+
// Requests a connection with another service. The service originating the
// request is referred to as the "source" and the one receiving the "target".
//
@@ -110,10 +115,6 @@
// are filtered by the security policy described by the source and target
// service manifests.
//
- // client_process_connection
- // When non-null, supplies control pipes the service manager can use to
- // bind a process created by the client, instead of creating one itself.
- //
// Response parameters:
//
// result
@@ -125,9 +126,7 @@
// resolved by the service manager into a valid user id returned through
// this callback.
//
- Connect(Identity target,
- InterfaceProvider&? remote_interfaces,
- ClientProcessConnection? client_process_connection) =>
+ Connect(Identity target, InterfaceProvider&? remote_interfaces) =>
(ConnectResult result, string user_id);
// Clones this Connector so it can be passed to another thread.
diff --git a/services/service_manager/service_manager.cc b/services/service_manager/service_manager.cc
index acfcaaf..a32333f 100644
--- a/services/service_manager/service_manager.cc
+++ b/services/service_manager/service_manager.cc
@@ -165,16 +165,6 @@
base::Unretained(this)));
}
- 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));
- }
-
bool StartWithFilePath(const base::FilePath& path) {
DCHECK(!service_);
DCHECK(!path.empty());
@@ -189,6 +179,10 @@
return true;
}
+ void BindPIDReceiver(mojom::PIDReceiverRequest request) {
+ pid_receiver_binding_.Bind(std::move(request));
+ }
+
mojom::RunningServiceInfoPtr CreateRunningServiceInfo() const {
mojom::RunningServiceInfoPtr info(mojom::RunningServiceInfo::New());
info->id = id_;
@@ -234,18 +228,42 @@
};
// mojom::Connector implementation:
- void Connect(const service_manager::Identity& in_target,
+ void Start(
+ const Identity& target,
+ mojo::ScopedMessagePipeHandle service_handle,
+ mojom::PIDReceiverRequest pid_receiver_request) override {
+ mojom::ServicePtr service;
+ service.Bind(mojom::ServicePtrInfo(std::move(service_handle), 0));
+ ConnectImpl(
+ target,
+ mojom::InterfaceProviderRequest(),
+ std::move(service),
+ std::move(pid_receiver_request),
+ base::Bind(
+ &service_manager::ServiceManager::Instance::EmptyConnectCallback,
+ weak_factory_.GetWeakPtr()));
+ }
+
+ void Connect(const service_manager::Identity& target,
mojom::InterfaceProviderRequest remote_interfaces,
- mojom::ClientProcessConnectionPtr client_process_connection,
const ConnectCallback& callback) override {
+ ConnectImpl(target, std::move(remote_interfaces), mojom::ServicePtr(),
+ mojom::PIDReceiverRequest(), callback);
+ }
+
+ void ConnectImpl(const service_manager::Identity& in_target,
+ mojom::InterfaceProviderRequest remote_interfaces,
+ mojom::ServicePtr service,
+ mojom::PIDReceiverRequest pid_receiver_request,
+ const ConnectCallback& callback) {
Identity target = in_target;
if (target.user_id() == mojom::kInheritUserID)
target.set_user_id(identity_.user_id());
if (!ValidateIdentity(target, callback))
return;
- if (!ValidateClientProcessConnection(&client_process_connection, target,
- callback)) {
+ if (!ValidateClientProcessInfo(&service, &pid_receiver_request, target,
+ callback)) {
return;
}
if (!ValidateConnectionSpec(target, callback))
@@ -255,7 +273,8 @@
params->set_source(identity_);
params->set_target(target);
params->set_remote_interfaces(std::move(remote_interfaces));
- params->set_client_process_connection(std::move(client_process_connection));
+ params->set_client_process_info(std::move(service),
+ std::move(pid_receiver_request));
params->set_connect_callback(callback);
service_manager_->Connect(
std::move(params), nullptr, weak_factory_.GetWeakPtr());
@@ -300,11 +319,12 @@
return true;
}
- bool ValidateClientProcessConnection(
- mojom::ClientProcessConnectionPtr* client_process_connection,
+ bool ValidateClientProcessInfo(
+ mojom::ServicePtr* service,
+ mojom::PIDReceiverRequest* pid_receiver_request,
const Identity& target,
const ConnectCallback& callback) {
- if (!client_process_connection->is_null()) {
+ if (service->is_bound() || pid_receiver_request->is_pending()) {
if (!HasCapability(GetConnectionSpec(), kCapability_ClientProcess)) {
LOG(ERROR) << "Instance: " << identity_.name() << " attempting "
<< "to register an instance for a process it created for "
@@ -316,11 +336,9 @@
return false;
}
- if (!(*client_process_connection)->service.is_valid() ||
- !(*client_process_connection)->pid_receiver_request.is_valid()) {
+ if (!service->is_bound() || !pid_receiver_request->is_pending()) {
LOG(ERROR) << "Must supply both service AND "
- << "pid_receiver_request when sending "
- << "client_process_connection.";
+ << "pid_receiver_request when sending client process info";
callback.Run(mojom::ConnectResult::INVALID_ARGUMENT,
mojom::kInheritUserID);
return false;
@@ -342,7 +360,7 @@
InterfaceProviderSpec connection_spec = GetConnectionSpec();
// TODO(beng): Need to do the following additional policy validation of
// whether this instance is allowed to connect using:
- // - a non-null client_process_connection.
+ // - non-null client process info.
if (target.user_id() != identity_.user_id() &&
target.user_id() != mojom::kRootUserID &&
!HasCapability(connection_spec, kCapability_UserID)) {
@@ -432,6 +450,9 @@
OnServiceLost(service_manager_->GetWeakPtr());
}
+ void EmptyConnectCallback(mojom::ConnectResult result,
+ const std::string& user_id) {}
+
service_manager::ServiceManager* const service_manager_;
// An id that identifies this instance. Distinct from pid, as a single process
@@ -872,8 +893,6 @@
source_identity_for_creation = params->source();
}
- mojom::ClientProcessConnectionPtr client_process_connection =
- params->TakeClientProcessConnection();
Instance* instance = CreateInstance(source_identity_for_creation,
target, result->interface_provider_specs);
@@ -883,11 +902,13 @@
// If a ServicePtr was provided, there's no more work to do: someone
// is already holding a corresponding ServiceRequest.
instance->StartWithService(std::move(service));
- } else if (!client_process_connection.is_null()) {
- // Likewise if a ClientProcessConnection was given via Connect(), it
- // provides the Service proxy to use.
- instance->StartWithClientProcessConnection(
- std::move(client_process_connection));
+ } else if (params->HasClientProcessInfo()) {
+ // This branch should be reachable only via a call to RegisterService(). We
+ // start the instance but return early before we connect to it. Clients will
+ // call Connect() with the target identity subsequently.
+ instance->BindPIDReceiver(params->TakePIDReceiverRequest());
+ instance->StartWithService(params->TakeService());
+ return;
} else {
// Otherwise we create a new Service pipe.
mojom::ServiceRequest request(&service);
diff --git a/services/service_manager/tests/connect/connect_test_app.cc b/services/service_manager/tests/connect/connect_test_app.cc
index 33988a6..7e3c4e3 100644
--- a/services/service_manager/tests/connect/connect_test_app.cc
+++ b/services/service_manager/tests/connect/connect_test_app.cc
@@ -172,9 +172,8 @@
void ConnectToClassAppAsDifferentUser(
const service_manager::Identity& target,
const ConnectToClassAppAsDifferentUserCallback& callback) override {
- Connector::ConnectParams params(target);
std::unique_ptr<Connection> connection =
- context()->connector()->Connect(¶ms);
+ context()->connector()->Connect(target);
{
base::RunLoop loop;
connection->AddConnectionCompletedClosure(base::Bind(&QuitLoop, &loop));
diff --git a/services/service_manager/tests/connect/connect_test_package.cc b/services/service_manager/tests/connect/connect_test_package.cc
index cef83518..6c142da8 100644
--- a/services/service_manager/tests/connect/connect_test_package.cc
+++ b/services/service_manager/tests/connect/connect_test_package.cc
@@ -116,9 +116,8 @@
void ConnectToClassAppAsDifferentUser(
const service_manager::Identity& target,
const ConnectToClassAppAsDifferentUserCallback& callback) override {
- Connector::ConnectParams params(target);
std::unique_ptr<Connection> connection =
- context()->connector()->Connect(¶ms);
+ context()->connector()->Connect(target);
{
base::RunLoop loop;
connection->AddConnectionCompletedClosure(loop.QuitClosure());
diff --git a/services/service_manager/tests/connect/connect_unittest.cc b/services/service_manager/tests/connect/connect_unittest.cc
index ee9fbed..e4f978c 100644
--- a/services/service_manager/tests/connect/connect_unittest.cc
+++ b/services/service_manager/tests/connect/connect_unittest.cc
@@ -79,8 +79,8 @@
~ConnectTest() override {}
protected:
- std::unique_ptr<Connection> ConnectTo(Connector::ConnectParams* params) {
- std::unique_ptr<Connection> connection = connector()->Connect(params);
+ std::unique_ptr<Connection> ConnectTo(const Identity& target) {
+ std::unique_ptr<Connection> connection = connector()->Connect(target);
base::RunLoop loop;
connection->AddConnectionCompletedClosure(base::Bind(&QuitLoop, &loop));
loop.Run();
@@ -175,10 +175,9 @@
}
TEST_F(ConnectTest, Instances) {
- Connector::ConnectParams params_a(
- Identity(kTestAppName, mojom::kInheritUserID, "A"));
- std::unique_ptr<Connection> connection_a1 = ConnectTo(¶ms_a);
- std::unique_ptr<Connection> connection_a2 = ConnectTo(¶ms_a);
+ Identity identity_a(kTestAppName, mojom::kInheritUserID, "A");
+ std::unique_ptr<Connection> connection_a1 = ConnectTo(identity_a);
+ std::unique_ptr<Connection> connection_a2 = ConnectTo(identity_a);
std::string instance_a1, instance_a2;
test::mojom::ConnectTestServicePtr service_a1;
{
@@ -196,9 +195,8 @@
}
EXPECT_EQ(instance_a1, instance_a2);
- Connector::ConnectParams params_b(
- Identity(kTestAppName, mojom::kInheritUserID, "B"));
- std::unique_ptr<Connection> connection_b = ConnectTo(¶ms_b);
+ Identity identity_b(kTestAppName, mojom::kInheritUserID, "B");
+ std::unique_ptr<Connection> connection_b = ConnectTo(identity_b);
std::string instance_b;
test::mojom::ConnectTestServicePtr service_b;
{
@@ -368,9 +366,8 @@
// own
// synthetic user id for all-user singleton instances).
const std::string singleton_userid = base::GenerateGUID();
- Connector::ConnectParams params(
- Identity(kTestSingletonAppName, singleton_userid));
- std::unique_ptr<Connection> connection = connector()->Connect(¶ms);
+ Identity singleton_id(kTestSingletonAppName, singleton_userid);
+ std::unique_ptr<Connection> connection = connector()->Connect(singleton_id);
{
base::RunLoop loop;
connection->AddConnectionCompletedClosure(base::Bind(&QuitLoop, &loop));
diff --git a/services/service_manager/tests/service_manager/service_manager_unittest.cc b/services/service_manager/tests/service_manager/service_manager_unittest.cc
index 9c299c5..052ee6e 100644
--- a/services/service_manager/tests/service_manager/service_manager_unittest.cc
+++ b/services/service_manager/tests/service_manager/service_manager_unittest.cc
@@ -184,11 +184,9 @@
service_manager::Identity target("service_manager_unittest_target",
service_manager::mojom::kInheritUserID);
- service_manager::Connector::ConnectParams params(target);
- params.set_client_process_connection(std::move(client),
- MakeRequest(&receiver));
+ connector()->Start(target, std::move(client), MakeRequest(&receiver));
std::unique_ptr<service_manager::Connection> connection =
- connector()->Connect(¶ms);
+ connector()->Connect(target);
connection->AddConnectionCompletedClosure(
base::Bind(&ServiceManagerTest::OnConnectionCompleted,
base::Unretained(this)));
diff --git a/services/service_manager/tests/util.cc b/services/service_manager/tests/util.cc
index 1cc1088..b15abd1 100644
--- a/services/service_manager/tests/util.cc
+++ b/services/service_manager/tests/util.cc
@@ -36,7 +36,7 @@
std::unique_ptr<Connection> LaunchAndConnectToProcess(
const std::string& target_exe_name,
- const Identity target,
+ const Identity& target,
service_manager::Connector* connector,
base::Process* process) {
base::FilePath target_path;
@@ -74,11 +74,9 @@
std::move(pipe), 0u));
service_manager::mojom::PIDReceiverPtr receiver;
- service_manager::Connector::ConnectParams params(target);
- params.set_client_process_connection(std::move(client),
- MakeRequest(&receiver));
+ connector->Start(target, std::move(client), MakeRequest(&receiver));
std::unique_ptr<service_manager::Connection> connection =
- connector->Connect(¶ms);
+ connector->Connect(target);
{
base::RunLoop loop;
connection->AddConnectionCompletedClosure(base::Bind(&QuitLoop, &loop));
diff --git a/services/service_manager/tests/util.h b/services/service_manager/tests/util.h
index aac2900c..6fe6bc3 100644
--- a/services/service_manager/tests/util.h
+++ b/services/service_manager/tests/util.h
@@ -25,7 +25,7 @@
// manager.
std::unique_ptr<Connection> LaunchAndConnectToProcess(
const std::string& target_exe_name,
- const Identity target,
+ const Identity& target,
service_manager::Connector* connector,
base::Process* process);
diff --git a/third_party/WebKit/Source/platform/ServiceConnector.h b/third_party/WebKit/Source/platform/ServiceConnector.h
index 6d6b56b..250a4018 100644
--- a/third_party/WebKit/Source/platform/ServiceConnector.h
+++ b/third_party/WebKit/Source/platform/ServiceConnector.h
@@ -39,7 +39,7 @@
service_manager::mojom::blink::InterfaceProviderPtr remoteInterfaces;
m_connector->Connect(std::move(remoteIdentity),
- MakeRequest(&remoteInterfaces), nullptr,
+ MakeRequest(&remoteInterfaces),
base::Bind(&ServiceConnector::onConnectionCompleted));
remoteInterfaces->GetInterface(Interface::Name_, request.PassMessagePipe());
