replace NULL->nullptr in src/remoting.

remoting/host/local_input_monitor_x11.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/local_input_monitor.h"
 
 #include <sys/select.h>
 #include <unistd.h>
 #define XK_MISCELLANY
 #include <X11/keysymdef.h>
@@ skipping 107 matching lines @@
 
 LocalInputMonitorX11::Core::Core(
     scoped_refptr<base::SingleThreadTaskRunner> caller_task_runner,
     scoped_refptr<base::SingleThreadTaskRunner> input_task_runner,
     base::WeakPtr<ClientSessionControl> client_session_control)
     : caller_task_runner_(caller_task_runner),
       input_task_runner_(input_task_runner),
       client_session_control_(client_session_control),
       alt_pressed_(false),
       ctrl_pressed_(false),
-      display_(NULL),
-      x_record_display_(NULL),
+      display_(nullptr),
+      x_record_display_(nullptr),
       x_record_context_(0) {
   DCHECK(caller_task_runner_->BelongsToCurrentThread());
   DCHECK(client_session_control_.get());
 
-  x_record_range_[0] = NULL;
-  x_record_range_[1] = NULL;
+  x_record_range_[0] = nullptr;
+  x_record_range_[1] = nullptr;
 }
 
 void LocalInputMonitorX11::Core::Start() {
   DCHECK(caller_task_runner_->BelongsToCurrentThread());
 
   input_task_runner_->PostTask(FROM_HERE,
                                base::Bind(&Core::StartOnInputThread, this));
 }
 
 void LocalInputMonitorX11::Core::Stop() {
@@ skipping 17 matching lines @@
   DCHECK(!x_record_display_);
   DCHECK(!x_record_range_[0]);
   DCHECK(!x_record_range_[1]);
   DCHECK(!x_record_context_);
 
   // TODO(jamiewalch): We should pass the display in. At that point, since
   // XRecord needs a private connection to the X Server for its data channel
   // and both channels are used from a separate thread, we'll need to duplicate
   // them with something like the following:
   //   XOpenDisplay(DisplayString(display));
-  display_ = XOpenDisplay(NULL);
-  x_record_display_ = XOpenDisplay(NULL);
+  display_ = XOpenDisplay(nullptr);
+  x_record_display_ = XOpenDisplay(nullptr);
   if (!display_ || !x_record_display_) {
     LOG(ERROR) << "Couldn't open X display";
     return;
   }
 
   int xr_opcode, xr_event, xr_error;
   if (!XQueryExtension(display_, "RECORD", &xr_opcode, &xr_event, &xr_error)) {
     LOG(ERROR) << "X Record extension not available.";
     return;
   }
@@ skipping 53 matching lines @@
   // any X protocol traffic over the data channel while it's recording.
   if (x_record_context_) {
     XRecordDisableContext(display_, x_record_context_);
     XFlush(display_);
   }
 
   controller_.StopWatchingFileDescriptor();
 
   if (x_record_range_[0]) {
     XFree(x_record_range_[0]);
-    x_record_range_[0] = NULL;
+    x_record_range_[0] = nullptr;
   }
   if (x_record_range_[1]) {
     XFree(x_record_range_[1]);
-    x_record_range_[1] = NULL;
+    x_record_range_[1] = nullptr;
   }
   if (x_record_context_) {
     XRecordFreeContext(x_record_display_, x_record_context_);
     x_record_context_ = 0;
   }
   if (x_record_display_) {
     XCloseDisplay(x_record_display_);
-    x_record_display_ = NULL;
+    x_record_display_ = nullptr;
   }
   if (display_) {
     XCloseDisplay(display_);
-    display_ = NULL;
+    display_ = nullptr;
   }
 }
 
 void LocalInputMonitorX11::Core::OnFileCanReadWithoutBlocking(int fd) {
   DCHECK(input_task_runner_->BelongsToCurrentThread());
 
   // Fetch pending events if any.
   while (XPending(x_record_display_)) {
     XEvent ev;
     XNextEvent(x_record_display_, &ev);
@@ skipping 45 matching lines @@
 scoped_ptr<LocalInputMonitor> LocalInputMonitor::Create(
     scoped_refptr<base::SingleThreadTaskRunner> caller_task_runner,
     scoped_refptr<base::SingleThreadTaskRunner> input_task_runner,
     scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner,
     base::WeakPtr<ClientSessionControl> client_session_control) {
   return make_scoped_ptr(new LocalInputMonitorX11(
       caller_task_runner, input_task_runner, client_session_control));
 }
 
 }  // namespace remoting