remoting/host/win/worker_process_launcher_unittest.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "base/basictypes.h"
   6 #include "base/bind.h"
   7 #include "base/memory/ref_counted.h"
   8 #include "base/message_loop/message_loop.h"
   9 #include "base/win/scoped_handle.h"
  10 #include "base/win/scoped_process_information.h"
  11 #include "ipc/ipc_channel.h"
  12 #include "ipc/ipc_channel_proxy.h"
  13 #include "ipc/ipc_listener.h"
  14 #include "ipc/ipc_message.h"
  15 #include "remoting/base/auto_thread_task_runner.h"
  16 #include "remoting/host/chromoting_messages.h"
  17 #include "remoting/host/host_exit_codes.h"
  18 #include "remoting/host/ipc_util.h"
  19 #include "remoting/host/win/launch_process_with_token.h"
  20 #include "remoting/host/win/worker_process_launcher.h"
  21 #include "remoting/host/worker_process_ipc_delegate.h"
  22 #include "testing/gmock/include/gmock/gmock.h"
  23 #include "testing/gmock_mutant.h"
  24 #include "testing/gtest/include/gtest/gtest.h"
  25
  26 using base::win::ScopedHandle;
  27 using testing::_;
  28 using testing::AnyNumber;
  29 using testing::CreateFunctor;
  30 using testing::DoAll;
  31 using testing::Expectation;
  32 using testing::Invoke;
  33 using testing::InvokeWithoutArgs;
  34 using testing::Return;
  35
  36 namespace remoting {
  37
  38 namespace {
  39
  40 const char kIpcSecurityDescriptor[] = "D:(A;;GA;;;AU)";
  41
  42 class MockProcessLauncherDelegate : public WorkerProcessLauncher::Delegate {
  43  public:
  44   MockProcessLauncherDelegate() {}
  45   virtual ~MockProcessLauncherDelegate() {}
  46
  47   // WorkerProcessLauncher::Delegate interface.
  48   MOCK_METHOD1(LaunchProcess, void(WorkerProcessLauncher*));
  49   MOCK_METHOD1(Send, void(IPC::Message*));
  50   MOCK_METHOD0(CloseChannel, void());
  51   MOCK_METHOD0(KillProcess, void());
  52
  53  private:
  54   DISALLOW_COPY_AND_ASSIGN(MockProcessLauncherDelegate);
  55 };
  56
  57 class MockIpcDelegate : public WorkerProcessIpcDelegate {
  58  public:
  59   MockIpcDelegate() {}
  60   virtual ~MockIpcDelegate() {}
  61
  62   // WorkerProcessIpcDelegate interface.
  63   MOCK_METHOD1(OnChannelConnected, void(int32));
  64   MOCK_METHOD1(OnMessageReceived, bool(const IPC::Message&));
  65   MOCK_METHOD1(OnPermanentError, void(int));
  66
  67  private:
  68   DISALLOW_COPY_AND_ASSIGN(MockIpcDelegate);
  69 };
  70
  71 class MockWorkerListener : public IPC::Listener {
  72  public:
  73   MockWorkerListener() {}
  74   virtual ~MockWorkerListener() {}
  75
  76   MOCK_METHOD3(OnCrash, void(const std::string&, const std::string&, int));
  77
  78   // IPC::Listener implementation
  79   virtual bool OnMessageReceived(const IPC::Message& message) override;
  80
  81  private:
  82   DISALLOW_COPY_AND_ASSIGN(MockWorkerListener);
  83 };
  84
  85 bool MockWorkerListener::OnMessageReceived(const IPC::Message& message) {
  86   bool handled = true;
  87   IPC_BEGIN_MESSAGE_MAP(MockWorkerListener, message)
  88     IPC_MESSAGE_HANDLER(ChromotingDaemonMsg_Crash, OnCrash)
  89     IPC_MESSAGE_UNHANDLED(handled = false)
  90   IPC_END_MESSAGE_MAP()
  91
  92   EXPECT_TRUE(handled);
  93
  94   return handled;
  95 }
  96
  97 }  // namespace
  98
  99 class WorkerProcessLauncherTest
 100     : public testing::Test,
 101       public IPC::Listener {
 102  public:
 103   WorkerProcessLauncherTest();
 104   virtual ~WorkerProcessLauncherTest();
 105
 106   virtual void SetUp() override;
 107   virtual void TearDown() override;
 108
 109   // IPC::Listener implementation.
 110   virtual bool OnMessageReceived(const IPC::Message& message) override;
 111   virtual void OnChannelConnected(int32 peer_pid) override;
 112   virtual void OnChannelError() override;
 113
 114   // WorkerProcessLauncher::Delegate mocks
 115   void LaunchProcess(
 116       WorkerProcessLauncher* event_handler);
 117   void LaunchProcessAndConnect(
 118       WorkerProcessLauncher* event_handler);
 119   void FailLaunchAndStopWorker(
 120       WorkerProcessLauncher* event_handler);
 121   void KillProcess();
 122
 123   void TerminateWorker(DWORD exit_code);
 124
 125   // Connects the client end of the channel (the worker process's end).
 126   void ConnectClient();
 127
 128   // Disconnects the client end of the channel.
 129   void DisconnectClient();
 130
 131   // Disconnects the server end of the channel (the launcher's end).
 132   void DisconnectServer();
 133
 134   // Sends a message to the worker process.
 135   void SendToProcess(IPC::Message* message);
 136
 137   // Sends a fake message to the launcher.
 138   void SendFakeMessageToLauncher();
 139
 140   // Requests the worker to crash.
 141   void CrashWorker();
 142
 143   // Starts the worker.
 144   void StartWorker();
 145
 146   // Stops the worker.
 147   void StopWorker();
 148
 149   // Quits |message_loop_|.
 150   void QuitMainMessageLoop();
 151
 152  protected:
 153   void DoLaunchProcess();
 154
 155   base::MessageLoopForIO message_loop_;
 156   scoped_refptr<AutoThreadTaskRunner> task_runner_;
 157
 158   // Receives messages sent to the worker process.
 159   MockWorkerListener client_listener_;
 160
 161   // Receives messages sent from the worker process.
 162   MockIpcDelegate server_listener_;
 163
 164   // Implements WorkerProcessLauncher::Delegate.
 165   scoped_ptr<MockProcessLauncherDelegate> launcher_delegate_;
 166
 167   // The name of the IPC channel.
 168   std::string channel_name_;
 169
 170   // Client and server ends of the IPC channel.
 171   scoped_ptr<IPC::ChannelProxy> channel_client_;
 172   scoped_ptr<IPC::ChannelProxy> channel_server_;
 173
 174   WorkerProcessLauncher* event_handler_;
 175
 176   // The worker process launcher.
 177   scoped_ptr<WorkerProcessLauncher> launcher_;
 178
 179   // An event that is used to emulate the worker process's handle.
 180   ScopedHandle worker_process_;
 181 };
 182
 183 WorkerProcessLauncherTest::WorkerProcessLauncherTest()
 184     : event_handler_(nullptr) {
 185 }
 186
 187 WorkerProcessLauncherTest::~WorkerProcessLauncherTest() {
 188 }
 189
 190 void WorkerProcessLauncherTest::SetUp() {
 191   task_runner_ = new AutoThreadTaskRunner(
 192       message_loop_.message_loop_proxy(),
 193       base::Bind(&WorkerProcessLauncherTest::QuitMainMessageLoop,
 194                  base::Unretained(this)));
 195
 196   // Set up process launcher delegate
 197   launcher_delegate_.reset(new MockProcessLauncherDelegate());
 198   EXPECT_CALL(*launcher_delegate_, Send(_))
 199       .Times(AnyNumber())
 200       .WillRepeatedly(Invoke(this, &WorkerProcessLauncherTest::SendToProcess));
 201   EXPECT_CALL(*launcher_delegate_, CloseChannel())
 202       .Times(AnyNumber())
 203       .WillRepeatedly(Invoke(this,
 204                              &WorkerProcessLauncherTest::DisconnectServer));
 205   EXPECT_CALL(*launcher_delegate_, KillProcess())
 206       .Times(AnyNumber())
 207       .WillRepeatedly(Invoke(this, &WorkerProcessLauncherTest::KillProcess));
 208
 209   // Set up IPC delegate.
 210   EXPECT_CALL(server_listener_, OnMessageReceived(_))
 211       .Times(0);
 212 }
 213
 214 void WorkerProcessLauncherTest::TearDown() {
 215 }
 216
 217 bool WorkerProcessLauncherTest::OnMessageReceived(const IPC::Message& message) {
 218   return event_handler_->OnMessageReceived(message);
 219 }
 220
 221 void WorkerProcessLauncherTest::OnChannelConnected(int32 peer_pid) {
 222   event_handler_->OnChannelConnected(peer_pid);
 223 }
 224
 225 void WorkerProcessLauncherTest::OnChannelError() {
 226   event_handler_->OnChannelError();
 227 }
 228
 229 void WorkerProcessLauncherTest::LaunchProcess(
 230     WorkerProcessLauncher* event_handler) {
 231   EXPECT_FALSE(event_handler_);
 232   event_handler_ = event_handler;
 233
 234   DoLaunchProcess();
 235 }
 236
 237 void WorkerProcessLauncherTest::LaunchProcessAndConnect(
 238     WorkerProcessLauncher* event_handler) {
 239   EXPECT_FALSE(event_handler_);
 240   event_handler_ = event_handler;
 241
 242   DoLaunchProcess();
 243
 244   task_runner_->PostTask(
 245       FROM_HERE,
 246       base::Bind(&WorkerProcessLauncherTest::ConnectClient,
 247                  base::Unretained(this)));
 248 }
 249
 250 void WorkerProcessLauncherTest::FailLaunchAndStopWorker(
 251     WorkerProcessLauncher* event_handler) {
 252   EXPECT_FALSE(event_handler_);
 253
 254   event_handler->OnFatalError();
 255
 256   task_runner_->PostTask(
 257       FROM_HERE,
 258       base::Bind(&WorkerProcessLauncherTest::StopWorker,
 259                  base::Unretained(this)));
 260 }
 261
 262 void WorkerProcessLauncherTest::KillProcess() {
 263   event_handler_ = nullptr;
 264
 265   if (worker_process_.IsValid()) {
 266     TerminateProcess(worker_process_.Get(), CONTROL_C_EXIT);
 267     worker_process_.Close();
 268   }
 269 }
 270
 271 void WorkerProcessLauncherTest::TerminateWorker(DWORD exit_code) {
 272   if (worker_process_.IsValid())
 273     TerminateProcess(worker_process_.Get(), exit_code);
 274 }
 275
 276 void WorkerProcessLauncherTest::ConnectClient() {
 277   channel_client_ = IPC::ChannelProxy::Create(IPC::ChannelHandle(channel_name_),
 278                                               IPC::Channel::MODE_CLIENT,
 279                                               &client_listener_,
 280                                               task_runner_);
 281
 282   // Pretend that |kLaunchSuccessTimeoutSeconds| passed since launching
 283   // the worker process. This will make the backoff algorithm think that this
 284   // launch attempt was successful and it will not delay the next launch.
 285   launcher_->RecordSuccessfulLaunchForTest();
 286 }
 287
 288 void WorkerProcessLauncherTest::DisconnectClient() {
 289   channel_client_.reset();
 290 }
 291
 292 void WorkerProcessLauncherTest::DisconnectServer() {
 293   channel_server_.reset();
 294 }
 295
 296 void WorkerProcessLauncherTest::SendToProcess(IPC::Message* message) {
 297   if (channel_server_) {
 298     channel_server_->Send(message);
 299     return;
 300   }
 301
 302   delete message;
 303 }
 304
 305 void WorkerProcessLauncherTest::SendFakeMessageToLauncher() {
 306   if (channel_client_)
 307     channel_client_->Send(new ChromotingDesktopNetworkMsg_DisconnectSession());
 308 }
 309
 310 void WorkerProcessLauncherTest::CrashWorker() {
 311   launcher_->Crash(FROM_HERE);
 312 }
 313
 314 void WorkerProcessLauncherTest::StartWorker() {
 315   launcher_.reset(new WorkerProcessLauncher(
 316       launcher_delegate_.Pass(),
 317       &server_listener_));
 318
 319   launcher_->SetKillProcessTimeoutForTest(base::TimeDelta::FromMilliseconds(0));
 320 }
 321
 322 void WorkerProcessLauncherTest::StopWorker() {
 323   launcher_.reset();
 324   DisconnectClient();
 325   channel_name_.clear();
 326   channel_server_.reset();
 327   task_runner_ = nullptr;
 328 }
 329
 330 void WorkerProcessLauncherTest::QuitMainMessageLoop() {
 331   message_loop_.PostTask(FROM_HERE, base::MessageLoop::QuitClosure());
 332 }
 333
 334 void WorkerProcessLauncherTest::DoLaunchProcess() {
 335   EXPECT_TRUE(event_handler_);
 336   EXPECT_FALSE(worker_process_.IsValid());
 337
 338   WCHAR notepad[MAX_PATH + 1];
 339   ASSERT_GT(ExpandEnvironmentStrings(
 340       L"\045SystemRoot\045\\system32\\notepad.exe", notepad, MAX_PATH), 0u);
 341
 342   STARTUPINFOW startup_info = { 0 };
 343   startup_info.cb = sizeof(startup_info);
 344
 345   PROCESS_INFORMATION temp_process_info = {};
 346   ASSERT_TRUE(CreateProcess(nullptr,
 347                             notepad,
 348                             nullptr,   // default process attibutes
 349                             nullptr,   // default thread attibutes
 350                             FALSE,  // do not inherit handles
 351                             CREATE_SUSPENDED,
 352                             nullptr,   // no environment
 353                             nullptr,   // default current directory
 354                             &startup_info,
 355                             &temp_process_info));
 356   base::win::ScopedProcessInformation process_information(temp_process_info);
 357   worker_process_.Set(process_information.TakeProcessHandle());
 358   ASSERT_TRUE(worker_process_.IsValid());
 359
 360   channel_name_ = IPC::Channel::GenerateUniqueRandomChannelID();
 361   ScopedHandle pipe;
 362   ASSERT_TRUE(CreateIpcChannel(channel_name_, kIpcSecurityDescriptor, &pipe));
 363
 364   // Wrap the pipe into an IPC channel.
 365   channel_server_ = IPC::ChannelProxy::Create(
 366       IPC::ChannelHandle(pipe.Get()), IPC::Channel::MODE_SERVER, this,
 367       task_runner_);
 368
 369   HANDLE temp_handle;
 370   ASSERT_TRUE(DuplicateHandle(GetCurrentProcess(),
 371                               worker_process_.Get(),
 372                               GetCurrentProcess(),
 373                               &temp_handle,
 374                               0,
 375                               FALSE,
 376                               DUPLICATE_SAME_ACCESS));
 377   ScopedHandle copy(temp_handle);
 378
 379   event_handler_->OnProcessLaunched(copy.Pass());
 380 }
 381
 382 TEST_F(WorkerProcessLauncherTest, Start) {
 383   EXPECT_CALL(*launcher_delegate_, LaunchProcess(_))
 384       .Times(1)
 385       .WillRepeatedly(Invoke(this, &WorkerProcessLauncherTest::LaunchProcess));
 386
 387   EXPECT_CALL(server_listener_, OnChannelConnected(_))
 388       .Times(0);
 389   EXPECT_CALL(server_listener_, OnPermanentError(_))
 390       .Times(0);
 391
 392   StartWorker();
 393   StopWorker();
 394   message_loop_.Run();
 395 }
 396
 397 // Starts and connects to the worker process. Expect OnChannelConnected to be
 398 // called.
 399 TEST_F(WorkerProcessLauncherTest, StartAndConnect) {
 400   EXPECT_CALL(*launcher_delegate_, LaunchProcess(_))
 401       .Times(1)
 402       .WillRepeatedly(Invoke(
 403           this, &WorkerProcessLauncherTest::LaunchProcessAndConnect));
 404
 405   EXPECT_CALL(server_listener_, OnChannelConnected(_))
 406       .Times(1)
 407       .WillOnce(InvokeWithoutArgs(this,
 408                                   &WorkerProcessLauncherTest::StopWorker));
 409   EXPECT_CALL(server_listener_, OnPermanentError(_))
 410       .Times(0);
 411
 412   StartWorker();
 413   message_loop_.Run();
 414 }
 415
 416 // Kills the worker process after the 1st connect and expects it to be
 417 // restarted.
 418 TEST_F(WorkerProcessLauncherTest, Restart) {
 419   EXPECT_CALL(*launcher_delegate_, LaunchProcess(_))
 420       .Times(2)
 421       .WillRepeatedly(Invoke(
 422           this, &WorkerProcessLauncherTest::LaunchProcessAndConnect));
 423   Expectation first_connect =
 424       EXPECT_CALL(server_listener_, OnChannelConnected(_))
 425           .Times(2)
 426           .WillOnce(InvokeWithoutArgs(CreateFunctor(
 427               this, &WorkerProcessLauncherTest::TerminateWorker,
 428               CONTROL_C_EXIT)))
 429           .WillOnce(InvokeWithoutArgs(this,
 430                                       &WorkerProcessLauncherTest::StopWorker));
 431
 432   EXPECT_CALL(server_listener_, OnPermanentError(_))
 433       .Times(0);
 434
 435   StartWorker();
 436   message_loop_.Run();
 437 }
 438
 439 // Drops the IPC channel to the worker process after the 1st connect and expects
 440 // the worker process to be restarted.
 441 TEST_F(WorkerProcessLauncherTest, DropIpcChannel) {
 442   EXPECT_CALL(*launcher_delegate_, LaunchProcess(_))
 443       .Times(2)
 444       .WillRepeatedly(Invoke(
 445           this, &WorkerProcessLauncherTest::LaunchProcessAndConnect));
 446
 447   Expectation first_connect =
 448       EXPECT_CALL(server_listener_, OnChannelConnected(_))
 449           .Times(2)
 450           .WillOnce(InvokeWithoutArgs(
 451               this, &WorkerProcessLauncherTest::DisconnectClient))
 452           .WillOnce(InvokeWithoutArgs(
 453               this, &WorkerProcessLauncherTest::StopWorker));
 454
 455   EXPECT_CALL(server_listener_, OnPermanentError(_))
 456       .Times(0);
 457
 458   StartWorker();
 459   message_loop_.Run();
 460 }
 461
 462 // Returns a permanent error exit code and expects OnPermanentError() to be
 463 // invoked.
 464 TEST_F(WorkerProcessLauncherTest, PermanentError) {
 465   EXPECT_CALL(*launcher_delegate_, LaunchProcess(_))
 466       .Times(1)
 467       .WillRepeatedly(Invoke(
 468           this, &WorkerProcessLauncherTest::LaunchProcessAndConnect));
 469
 470   EXPECT_CALL(server_listener_, OnChannelConnected(_))
 471       .Times(1)
 472       .WillOnce(InvokeWithoutArgs(CreateFunctor(
 473           this, &WorkerProcessLauncherTest::TerminateWorker,
 474           kMinPermanentErrorExitCode)));
 475   EXPECT_CALL(server_listener_, OnPermanentError(_))
 476       .Times(1)
 477       .WillOnce(InvokeWithoutArgs(this,
 478                                   &WorkerProcessLauncherTest::StopWorker));
 479
 480   StartWorker();
 481   message_loop_.Run();
 482 }
 483
 484 // Requests the worker to crash and expects it to honor the request.
 485 TEST_F(WorkerProcessLauncherTest, Crash) {
 486   EXPECT_CALL(*launcher_delegate_, LaunchProcess(_))
 487       .Times(2)
 488       .WillRepeatedly(Invoke(
 489           this, &WorkerProcessLauncherTest::LaunchProcessAndConnect));
 490
 491   EXPECT_CALL(server_listener_, OnChannelConnected(_))
 492       .Times(2)
 493       .WillOnce(InvokeWithoutArgs(this,
 494                                   &WorkerProcessLauncherTest::CrashWorker))
 495       .WillOnce(InvokeWithoutArgs(this,
 496                                   &WorkerProcessLauncherTest::StopWorker));
 497
 498   EXPECT_CALL(client_listener_, OnCrash(_, _, _))
 499       .Times(1)
 500       .WillOnce(InvokeWithoutArgs(CreateFunctor(
 501           this, &WorkerProcessLauncherTest::TerminateWorker,
 502           EXCEPTION_BREAKPOINT)));
 503
 504   StartWorker();
 505   message_loop_.Run();
 506 }
 507
 508 // Requests the worker to crash and terminates the worker even if it does not
 509 // comply.
 510 TEST_F(WorkerProcessLauncherTest, CrashAnyway) {
 511   EXPECT_CALL(*launcher_delegate_, LaunchProcess(_))
 512       .Times(2)
 513       .WillRepeatedly(Invoke(
 514           this, &WorkerProcessLauncherTest::LaunchProcessAndConnect));
 515
 516   EXPECT_CALL(server_listener_, OnChannelConnected(_))
 517       .Times(2)
 518       .WillOnce(InvokeWithoutArgs(this,
 519                                   &WorkerProcessLauncherTest::CrashWorker))
 520       .WillOnce(InvokeWithoutArgs(this,
 521                                   &WorkerProcessLauncherTest::StopWorker));
 522
 523   // Ignore the crash request and try send another message to the launcher.
 524   EXPECT_CALL(client_listener_, OnCrash(_, _, _))
 525       .Times(1)
 526       .WillOnce(InvokeWithoutArgs(
 527           this, &WorkerProcessLauncherTest::SendFakeMessageToLauncher));
 528
 529   StartWorker();
 530   message_loop_.Run();
 531 }
 532
 533 }  // namespace remoting