replace NULL->nullptr in src/remoting.

remoting/host/curtain_mode_mac.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 "remoting/host/curtain_mode.h"
 
 #include <ApplicationServices/ApplicationServices.h>
 #include <Carbon/Carbon.h>
 #include <Security/Security.h>
 #include <unistd.h>
@@ skipping 66 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(SessionWatcher);
 };
 
 SessionWatcher::SessionWatcher(
     scoped_refptr<base::SingleThreadTaskRunner> caller_task_runner,
     scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner,
     base::WeakPtr<ClientSessionControl> client_session_control)
     : caller_task_runner_(caller_task_runner),
       ui_task_runner_(ui_task_runner),
       client_session_control_(client_session_control),
-      event_handler_(NULL) {
+      event_handler_(nullptr) {
 }
 
 void SessionWatcher::Start() {
   DCHECK(caller_task_runner_->BelongsToCurrentThread());
 
   // Activate curtain asynchronously since it has to be done on the UI thread.
   // Because the curtain activation is asynchronous, it is possible that
   // the connection will not be curtained for a brief moment. This seems to be
   // unaviodable as long as the curtain enforcement depends on processing of
   // the switch-in notifications.
@@ skipping 32 matching lines @@
   // current session so that the console session is not affected if it fails.
   if (!InstallEventHandler()) {
     LOG(ERROR) << "Failed to install the switch-in handler.";
     DisconnectSession();
     return;
   }
 
   base::ScopedCFTypeRef<CFDictionaryRef> session(
       CGSessionCopyCurrentDictionary());
 
-  // CGSessionCopyCurrentDictionary has been observed to return NULL in some
+  // CGSessionCopyCurrentDictionary has been observed to return nullptr in some
   // cases. Once the system is in this state, curtain mode will fail as the
   // CGSession command thinks the session is not attached to the console. The
   // only known remedy is logout or reboot. Since we're not sure what causes
   // this, or how common it is, a crash report is useful in this case (note
   // that the connection would have to be refused in any case, so this is no
   // loss of functionality).
-  CHECK(session != NULL);
+  CHECK(session != nullptr);
 
   const void* on_console = CFDictionaryGetValue(session,
                                                 kCGSessionOnConsoleKey);
   const void* logged_in = CFDictionaryGetValue(session, kCGSessionLoginDoneKey);
   if (logged_in == kCFBooleanTrue && on_console == kCFBooleanTrue) {
     pid_t child = fork();
     if (child == 0) {
-      execl(kCGSessionPath, kCGSessionPath, "-suspend", NULL);
+      execl(kCGSessionPath, kCGSessionPath, "-suspend", nullptr);
       _exit(1);
     } else if (child > 0) {
       int status = 0;
       waitpid(child, &status, 0);
       if (status != 0) {
         LOG(ERROR) << kCGSessionPath << " failed.";
         DisconnectSession();
         return;
       }
     } else {
       LOG(ERROR) << "fork() failed.";
       DisconnectSession();
       return;
     }
   }
 }
 
 bool SessionWatcher::InstallEventHandler() {
   DCHECK(ui_task_runner_->BelongsToCurrentThread());
   DCHECK(!event_handler_);
 
   EventTypeSpec event;
   event.eventClass = kEventClassSystem;
   event.eventKind = kEventSystemUserSessionActivated;
   OSStatus result = ::InstallApplicationEventHandler(
       NewEventHandlerUPP(SessionActivateHandler), 1, &event, this,
       &event_handler_);
   if (result != noErr) {
-    event_handler_ = NULL;
+    event_handler_ = nullptr;
     DisconnectSession();
     return false;
   }
 
   return true;
 }
 
 void SessionWatcher::RemoveEventHandler() {
   DCHECK(ui_task_runner_->BelongsToCurrentThread());
 
   if (event_handler_) {
     ::RemoveEventHandler(event_handler_);
-    event_handler_ = NULL;
+    event_handler_ = nullptr;
   }
 }
 
 void SessionWatcher::DisconnectSession() {
   if (!caller_task_runner_->BelongsToCurrentThread()) {
     caller_task_runner_->PostTask(
         FROM_HERE, base::Bind(&SessionWatcher::DisconnectSession, this));
     return;
   }
 
@@ skipping 50 matching lines @@
 // static
 scoped_ptr<CurtainMode> CurtainMode::Create(
     scoped_refptr<base::SingleThreadTaskRunner> caller_task_runner,
     scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner,
     base::WeakPtr<ClientSessionControl> client_session_control) {
   return make_scoped_ptr(new CurtainModeMac(
       caller_task_runner, ui_task_runner, client_session_control));
 }
 
 }  // namespace remoting