Allow client process information to be passed via Connector::Connect().

mojo/shell/tests/lifecycle/lifecycle_unittest.cc

 // Copyright 2016 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.
 
 #include "base/base_paths.h"
 #include "base/base_switches.h"
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/macros.h"
 #include "base/path_service.h"
@@ skipping 164 matching lines @@
   #endif
 
     base::CommandLine child_command_line(target_path);
     // Forward the wait-for-debugger flag but nothing else - we don't want to
     // stamp on the platform-channel flag.
     if (base::CommandLine::ForCurrentProcess()->HasSwitch(
             switches::kWaitForDebugger)) {
       child_command_line.AppendSwitch(switches::kWaitForDebugger);
     }
 
-    mojo::shell::mojom::PIDReceiverPtr receiver;
-    mojo::InterfaceRequest<mojo::shell::mojom::PIDReceiver> request =
-        GetProxy(&receiver);
-
     // Create the channel to be shared with the target process. Pass one end
     // on the command line.
     mojo::edk::PlatformChannelPair platform_channel_pair;
     mojo::edk::HandlePassingInformation handle_passing_info;
     platform_channel_pair.PrepareToPassClientHandleToChildProcess(
         &child_command_line, &handle_passing_info);
 
     // Generate a token for the child to find and connect to a primordial pipe
     // and pass that as well.
     std::string primordial_pipe_token = mojo::edk::GenerateRandomToken();
     child_command_line.AppendSwitchASCII(switches::kPrimordialPipeToken,
                                          primordial_pipe_token);
 
     // Allocate the pipe locally.
     mojo::ScopedMessagePipeHandle pipe =
         mojo::edk::CreateParentMessagePipe(primordial_pipe_token);
 
     mojo::shell::mojom::ShellPtr shell;
     connector()->ConnectToInterface("mojo:shell", &shell);
 
     mojo::shell::mojom::ShellClientFactoryPtr factory;
     factory.Bind(mojo::InterfacePtrInfo<mojo::shell::mojom::ShellClientFactory>(
         std::move(pipe), 0u));
+    mojo::shell::mojom::PIDReceiverPtr receiver;
+
+    mojo::Identity target(kTestExeName, mojo::shell::mojom::kInheritUserID);
+    mojo::Connector::ConnectParams params(target);
+    params.set_client_process_connection(std::move(factory),
+                                         GetProxy(&receiver));
+    scoped_ptr<mojo::Connection> connection = connector()->Connect(&params);
     base::RunLoop loop;
-    mojo::Identity target(kTestExeName, mojom::kInheritUserID);
-    shell->CreateInstance(std::move(factory),
-                          mojo::shell::mojom::Identity::From(target),
-                          std::move(request),
-                          base::Bind(&LifecycleTest::OnConnectionCompleted,
-                                     base::Unretained(this), &loop));
+    connection->AddConnectionCompletedClosure(base::Bind(&QuitLoop, &loop));
     loop.Run();
 
     base::LaunchOptions options;
   #if defined(OS_WIN)
     options.handles_to_inherit = &handle_passing_info;
   #elif defined(OS_POSIX)
     options.fds_to_remap = &handle_passing_info;
   #endif
     base::Process process = base::LaunchProcess(child_command_line, options);
     DCHECK(process.IsValid());
@@ skipping 22 matching lines @@
     mojom::ShellPtr shell;
     connector()->ConnectToInterface("mojo:shell", &shell);
     mojom::InstanceListenerPtr listener;
     base::RunLoop loop;
     InstanceState* state = new InstanceState(GetProxy(&listener), &loop);
     shell->AddInstanceListener(std::move(listener));
     loop.Run();
     return make_scoped_ptr(state);
   }
 
-  void OnConnectionCompleted(base::RunLoop* loop,
-                             mojom::ConnectResult result) {
-    loop->Quit();
-  }
-
   scoped_ptr<InstanceState> instances_;
 
   DISALLOW_COPY_AND_ASSIGN(LifecycleTest);
 };
 
 TEST_F(LifecycleTest, Standalone_GracefulQuit) {
   test::mojom::LifecycleControlPtr lifecycle = ConnectTo(kTestAppName);
 
   EXPECT_TRUE(instances()->HasInstanceForName(kTestAppName));
   EXPECT_EQ(1u, instances()->GetNewInstanceCount());
@@ skipping 224 matching lines @@
   loop.Run();
 
   WaitForInstanceDestruction();
   EXPECT_FALSE(instances()->HasInstanceForName(kTestExeName));
   EXPECT_EQ(0u, instances()->GetNewInstanceCount());
 }
 
 
 }  // namespace shell
 }  // namespace mojo