replace NULL->nullptr in src/remoting.

remoting/client/plugin/chromoting_instance.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/client/plugin/chromoting_instance.h"
 
 #include <string>
 #include <vector>
 
 #if defined(OS_NACL)
@@ skipping 150 matching lines @@
 // to the UI. This prevents a potential infinite loop if we encounter an error
 // while sending the log message to the UI.
 bool g_logging_to_plugin = false;
 bool g_has_logging_instance = false;
 base::LazyInstance<scoped_refptr<base::SingleThreadTaskRunner> >::Leaky
     g_logging_task_runner = LAZY_INSTANCE_INITIALIZER;
 base::LazyInstance<base::WeakPtr<ChromotingInstance> >::Leaky
     g_logging_instance = LAZY_INSTANCE_INITIALIZER;
 base::LazyInstance<base::Lock>::Leaky
     g_logging_lock = LAZY_INSTANCE_INITIALIZER;
-logging::LogMessageHandlerFunction g_logging_old_handler = NULL;
+logging::LogMessageHandlerFunction g_logging_old_handler = nullptr;
 
 }  // namespace
 
 // String sent in the "hello" message to the webapp to describe features.
 const char ChromotingInstance::kApiFeatures[] =
     "highQualityScaling injectKeyEvent sendClipboardItem remapKey trapKey "
     "notifyClientResolution pauseVideo pauseAudio asyncPin thirdPartyAuth "
     "pinlessAuth extensionMessage allowMouseLock videoControl";
 
 const char ChromotingInstance::kRequestedCapabilities[] = "";
@@ skipping 110 matching lines @@
 
 void ChromotingInstance::HandleMessage(const pp::Var& message) {
   if (!message.is_string()) {
     LOG(ERROR) << "Received a message that is not a string.";
     return;
   }
 
   scoped_ptr<base::Value> json(
       base::JSONReader::Read(message.AsString(),
                              base::JSON_ALLOW_TRAILING_COMMAS));
-  base::DictionaryValue* message_dict = NULL;
+  base::DictionaryValue* message_dict = nullptr;
   std::string method;
-  base::DictionaryValue* data = NULL;
+  base::DictionaryValue* data = nullptr;
   if (!json.get() ||
       !json->GetAsDictionary(&message_dict) ||
       !message_dict->GetString("method", &method) ||
       !message_dict->GetDictionary("data", &data)) {
     LOG(ERROR) << "Received invalid message:" << message.AsString();
     return;
   }
 
   if (method == "connect") {
     HandleConnect(*data);
@@ skipping 625 matching lines @@
 void ChromotingInstance::HandleDelegateLargeCursors() {
   cursor_setter_.set_delegate_stub(this);
 }
 
 void ChromotingInstance::Disconnect() {
   DCHECK(plugin_task_runner_->BelongsToCurrentThread());
 
   VLOG(0) << "Disconnecting from host.";
 
   // Disconnect the input pipeline and teardown the connection.
-  mouse_input_filter_.set_input_stub(NULL);
+  mouse_input_filter_.set_input_stub(nullptr);
   client_.reset();
   video_renderer_.reset();
 }
 
 void ChromotingInstance::PostChromotingMessage(const std::string& method,
                                                const pp::VarDictionary& data) {
   pp::VarDictionary message;
   message.Set(pp::Var("method"), pp::Var(method));
   message.Set(pp::Var("data"), data);
   PostMessage(message);
@@ skipping 75 matching lines @@
 void ChromotingInstance::UnregisterLoggingInstance() {
   base::AutoLock lock(g_logging_lock.Get());
 
   // Don't unregister unless we're the currently registered instance.
   if (this != g_logging_instance.Get().get())
     return;
 
   // Unregister this instance for logging.
   g_has_logging_instance = false;
   g_logging_instance.Get().reset();
-  g_logging_task_runner.Get() = NULL;
+  g_logging_task_runner.Get() = nullptr;
 
   VLOG(1) << "Unregistering global log handler";
 }
 
 // static
 bool ChromotingInstance::LogToUI(int severity, const char* file, int line,
                                  size_t message_start,
                                  const std::string& str) {
   // Note that we're reading |g_has_logging_instance| outside of a lock.
   // This lockless read is done so that we don't needlessly slow down global
@@ skipping 67 matching lines @@
                                       url_components.scheme.len);
   return url_scheme == kChromeExtensionUrlScheme;
 }
 
 bool ChromotingInstance::IsConnected() {
   return client_ &&
          (client_->connection_state() == protocol::ConnectionToHost::CONNECTED);
 }
 
 }  // namespace remoting