replace NULL->nullptr in src/remoting.

remoting/host/input_injector_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/input_injector.h"
 
 #include <X11/extensions/XInput.h>
 #include <X11/extensions/XTest.h>
 #include <X11/Xlib.h>
 #include <X11/XKBlib.h>
@@ skipping 38 matching lines @@
     Mod3Mask,
     Mod4Mask,
     ShiftMask | Mod2Mask,
     ShiftMask | Mod3Mask,
     ShiftMask | Mod4Mask,
   };
 
   // TODO(sergeyu): Is there a better way to find modifiers state?
   for (size_t i = 0; i < arraysize(kModifiersToTry); ++i) {
     unsigned long key_sym_with_mods;
-    if (XkbLookupKeySym(
-            display, *keycode, kModifiersToTry[i], NULL, &key_sym_with_mods) &&
+    if (XkbLookupKeySym(display, *keycode, kModifiersToTry[i], nullptr,
+                        &key_sym_with_mods) &&
         key_sym_with_mods == key_sym) {
       *modifiers = kModifiersToTry[i];
       return true;
     }
   }
 
   return false;
 }
 
 // Finds a keycode and set of modifiers that generate character with the
@@ skipping 152 matching lines @@
     scoped_ptr<protocol::ClipboardStub> client_clipboard) {
   core_->Start(client_clipboard.Pass());
 }
 
 InputInjectorX11::Core::Core(
     scoped_refptr<base::SingleThreadTaskRunner> task_runner)
     : task_runner_(task_runner),
       latest_mouse_position_(-1, -1),
       wheel_ticks_x_(0.0f),
       wheel_ticks_y_(0.0f),
-      display_(XOpenDisplay(NULL)),
+      display_(XOpenDisplay(nullptr)),
       root_window_(BadValue),
       saved_auto_repeat_enabled_(false) {
 }
 
 bool InputInjectorX11::Core::Init() {
   CHECK(display_);
 
   if (!task_runner_->BelongsToCurrentThread())
     task_runner_->PostTask(FROM_HERE, base::Bind(&Core::InitClipboard, this));
 
@@ skipping 249 matching lines @@
   XFlush(display_);
 }
 
 void InputInjectorX11::Core::InitMouseButtonMap() {
   // TODO(rmsousa): Run this on global/device mapping change events.
 
   // Do not touch global pointer mapping, since this may affect the local user.
   // Instead, try to work around it by reversing the mapping.
   // Note that if a user has a global mapping that completely disables a button
   // (by assigning 0 to it), we won't be able to inject it.
-  int num_buttons = XGetPointerMapping(display_, NULL, 0);
+  int num_buttons = XGetPointerMapping(display_, nullptr, 0);
   scoped_ptr<unsigned char[]> pointer_mapping(new unsigned char[num_buttons]);
   num_buttons = XGetPointerMapping(display_, pointer_mapping.get(),
                                    num_buttons);
   for (int i = 0; i < kNumPointerButtons; i++) {
     pointer_button_map_[i] = -1;
   }
   for (int i = 0; i < num_buttons; i++) {
     // Reverse the mapping.
     if (pointer_mapping[i] > 0 && pointer_mapping[i] <= kNumPointerButtons)
       pointer_button_map_[pointer_mapping[i] - 1] = i + 1;
@@ skipping 35 matching lines @@
     HOST_LOG << "Cannot find XTest device.";
     return;
   }
 
   XDevice* device = XOpenDevice(display_, device_id);
   if (!device) {
     LOG(ERROR) << "Cannot open XTest device.";
     return;
   }
 
-  int num_device_buttons = XGetDeviceButtonMapping(display_, device, NULL, 0);
+  int num_device_buttons =
+      XGetDeviceButtonMapping(display_, device, nullptr, 0);
   scoped_ptr<unsigned char[]> button_mapping(new unsigned char[num_buttons]);
   for (int i = 0; i < num_device_buttons; i++) {
     button_mapping[i] = i + 1;
   }
   error = XSetDeviceButtonMapping(display_, device, button_mapping.get(),
                                   num_device_buttons);
   if (error != Success)
     LOG(ERROR) << "Failed to set XTest device button mapping: " << error;
 
   XCloseDevice(display_, device);
@@ skipping 56 matching lines @@
     scoped_refptr<base::SingleThreadTaskRunner> main_task_runner,
     scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner) {
   scoped_ptr<InputInjectorX11> injector(
       new InputInjectorX11(main_task_runner));
   if (!injector->Init())
     return nullptr;
   return injector.Pass();
 }
 
 }  // namespace remoting