replace NULL->nullptr in src/remoting.

remoting/host/win/worker_process_launcher_unittest.cc

 // Copyright (c) 2012 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/basictypes.h"
 #include "base/bind.h"
 #include "base/memory/ref_counted.h"
 #include "base/message_loop/message_loop.h"
 #include "base/win/scoped_handle.h"
 #include "base/win/scoped_process_information.h"
@@ skipping 162 matching lines @@
 
   WorkerProcessLauncher* event_handler_;
 
   // The worker process launcher.
   scoped_ptr<WorkerProcessLauncher> launcher_;
 
   // An event that is used to emulate the worker process's handle.
   ScopedHandle worker_process_;
 };
 
-WorkerProcessLauncherTest::WorkerProcessLauncherTest() : event_handler_(NULL) {
+WorkerProcessLauncherTest::WorkerProcessLauncherTest()
+    : event_handler_(nullptr) {
 }
 
 WorkerProcessLauncherTest::~WorkerProcessLauncherTest() {
 }
 
 void WorkerProcessLauncherTest::SetUp() {
   task_runner_ = new AutoThreadTaskRunner(
       message_loop_.message_loop_proxy(),
       base::Bind(&WorkerProcessLauncherTest::QuitMainMessageLoop,
                  base::Unretained(this)));
@@ skipping 58 matching lines @@
 
   event_handler->OnFatalError();
 
   task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&WorkerProcessLauncherTest::StopWorker,
                  base::Unretained(this)));
 }
 
 void WorkerProcessLauncherTest::KillProcess() {
-  event_handler_ = NULL;
+  event_handler_ = nullptr;
 
   if (worker_process_.IsValid()) {
     TerminateProcess(worker_process_.Get(), CONTROL_C_EXIT);
     worker_process_.Close();
   }
 }
 
 void WorkerProcessLauncherTest::TerminateWorker(DWORD exit_code) {
   if (worker_process_.IsValid())
     TerminateProcess(worker_process_.Get(), exit_code);
@@ skipping 43 matching lines @@
       &server_listener_));
 
   launcher_->SetKillProcessTimeoutForTest(base::TimeDelta::FromMilliseconds(0));
 }
 
 void WorkerProcessLauncherTest::StopWorker() {
   launcher_.reset();
   DisconnectClient();
   channel_name_.clear();
   channel_server_.reset();
-  task_runner_ = NULL;
+  task_runner_ = nullptr;
 }
 
 void WorkerProcessLauncherTest::QuitMainMessageLoop() {
   message_loop_.PostTask(FROM_HERE, base::MessageLoop::QuitClosure());
 }
 
 void WorkerProcessLauncherTest::DoLaunchProcess() {
   EXPECT_TRUE(event_handler_);
   EXPECT_FALSE(worker_process_.IsValid());
 
   WCHAR notepad[MAX_PATH + 1];
   ASSERT_GT(ExpandEnvironmentStrings(
       L"\045SystemRoot\045\\system32\\notepad.exe", notepad, MAX_PATH), 0u);
 
   STARTUPINFOW startup_info = { 0 };
   startup_info.cb = sizeof(startup_info);
 
   PROCESS_INFORMATION temp_process_info = {};
-  ASSERT_TRUE(CreateProcess(NULL,
+  ASSERT_TRUE(CreateProcess(nullptr,
                             notepad,
-                            NULL,   // default process attibutes
-                            NULL,   // default thread attibutes
+                            nullptr,   // default process attibutes
+                            nullptr,   // default thread attibutes
                             FALSE,  // do not inherit handles
                             CREATE_SUSPENDED,
-                            NULL,   // no environment
-                            NULL,   // default current directory
+                            nullptr,   // no environment
+                            nullptr,   // default current directory
                             &startup_info,
                             &temp_process_info));
   base::win::ScopedProcessInformation process_information(temp_process_info);
   worker_process_.Set(process_information.TakeProcessHandle());
   ASSERT_TRUE(worker_process_.IsValid());
 
   channel_name_ = IPC::Channel::GenerateUniqueRandomChannelID();
   ScopedHandle pipe;
   ASSERT_TRUE(CreateIpcChannel(channel_name_, kIpcSecurityDescriptor, &pipe));
 
@@ skipping 160 matching lines @@
   EXPECT_CALL(client_listener_, OnCrash(_, _, _))
       .Times(1)
       .WillOnce(InvokeWithoutArgs(
           this, &WorkerProcessLauncherTest::SendFakeMessageToLauncher));
 
   StartWorker();
   message_loop_.Run();
 }
 
 }  // namespace remoting