replace NULL->nullptr in src/remoting.

remoting/protocol/channel_multiplexer.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/protocol/channel_multiplexer.h"
 
 #include <string.h>
 
 #include "base/bind.h"
 #include "base/callback.h"
@@ skipping 173 matching lines @@
 
 ChannelMultiplexer::MuxChannel::MuxChannel(
     ChannelMultiplexer* multiplexer,
     const std::string& name,
     int send_id)
     : multiplexer_(multiplexer),
       name_(name),
       send_id_(send_id),
       id_sent_(false),
       receive_id_(kChannelIdUnknown),
-      socket_(NULL) {
+      socket_(nullptr) {
 }
 
 ChannelMultiplexer::MuxChannel::~MuxChannel() {
   // Socket must be destroyed before the channel.
   DCHECK(!socket_);
   STLDeleteElements(&pending_packets_);
 }
 
 scoped_ptr<net::StreamSocket> ChannelMultiplexer::MuxChannel::CreateSocket() {
   DCHECK(!socket_);  // Can't create more than one socket per channel.
@@ skipping 15 matching lines @@
   }
 }
 
 void ChannelMultiplexer::MuxChannel::OnWriteFailed() {
   if (socket_)
     socket_->OnWriteFailed();
 }
 
 void ChannelMultiplexer::MuxChannel::OnSocketDestroyed() {
   DCHECK(socket_);
-  socket_ = NULL;
+  socket_ = nullptr;
 }
 
 bool ChannelMultiplexer::MuxChannel::DoWrite(
     scoped_ptr<MultiplexPacket> packet,
     const base::Closure& done_task) {
   packet->set_channel_id(send_id_);
   if (!id_sent_) {
     packet->set_channel_name(name_);
     id_sent_ = true;
   }
@@ skipping 87 matching lines @@
   if (!write_callback_.is_null()) {
     net::CompletionCallback cb;
     std::swap(cb, write_callback_);
     cb.Run(net::ERR_FAILED);
   }
 }
 
 void ChannelMultiplexer::MuxSocket::OnPacketReceived() {
   if (!read_callback_.is_null()) {
     int result = channel_->DoRead(read_buffer_.get(), read_buffer_size_);
-    read_buffer_ = NULL;
+    read_buffer_ = nullptr;
     DCHECK_GT(result, 0);
     net::CompletionCallback cb;
     std::swap(cb, read_callback_);
     cb.Run(result);
   }
 }
 
 ChannelMultiplexer::ChannelMultiplexer(StreamChannelFactory* factory,
                                        const std::string& base_channel_name)
     : base_channel_factory_(factory),
@@ skipping 39 matching lines @@
        it != pending_channels_.end(); ++it) {
     if (it->name == name) {
       pending_channels_.erase(it);
       return;
     }
   }
 }
 
 void ChannelMultiplexer::OnBaseChannelReady(
     scoped_ptr<net::StreamSocket> socket) {
-  base_channel_factory_ = NULL;
+  base_channel_factory_ = nullptr;
   base_channel_ = socket.Pass();
 
   if (base_channel_.get()) {
     // Initialize reader and writer.
     reader_.Init(base_channel_.get(),
                  base::Bind(&ChannelMultiplexer::OnIncomingPacket,
                             base::Unretained(this)));
     writer_.Init(base_channel_.get(),
                  base::Bind(&ChannelMultiplexer::OnWriteFailed,
                             base::Unretained(this)));
@@ skipping 56 matching lines @@
 void ChannelMultiplexer::OnIncomingPacket(scoped_ptr<MultiplexPacket> packet,
                                           const base::Closure& done_task) {
   DCHECK(packet->has_channel_id());
   if (!packet->has_channel_id()) {
     LOG(ERROR) << "Received packet without channel_id.";
     done_task.Run();
     return;
   }
 
   int receive_id = packet->channel_id();
-  MuxChannel* channel = NULL;
+  MuxChannel* channel = nullptr;
   std::map<int, MuxChannel*>::iterator it =
       channels_by_receive_id_.find(receive_id);
   if (it != channels_by_receive_id_.end()) {
     channel = it->second;
   } else {
     // This is a new |channel_id| we haven't seen before. Look it up by name.
     if (!packet->has_channel_name()) {
       LOG(ERROR) << "Received packet with unknown channel_id and "
           "without channel_name.";
       done_task.Run();
       return;
     }
     channel = GetOrCreateChannel(packet->channel_name());
     channel->set_receive_id(receive_id);
     channels_by_receive_id_[receive_id] = channel;
   }
 
   channel->OnIncomingPacket(packet.Pass(), done_task);
 }
 
 bool ChannelMultiplexer::DoWrite(scoped_ptr<MultiplexPacket> packet,
                                  const base::Closure& done_task) {
   return writer_.Write(SerializeAndFrameMessage(*packet), done_task);
 }
 
 }  // namespace protocol
 }  // namespace remoting