replace NULL->nullptr in src/remoting.

remoting/protocol/ssl_hmac_channel_authenticator.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/ssl_hmac_channel_authenticator.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "crypto/secure_util.h"
 #include "net/base/host_port_pair.h"
@@ skipping 120 matching lines @@
                    base::Unretained(this)));
   }
 
   if (result == net::ERR_IO_PENDING)
     return;
 
   OnConnected(result);
 }
 
 bool SslHmacChannelAuthenticator::is_ssl_server() {
-  return local_key_pair_.get() != NULL;
+  return local_key_pair_.get() != nullptr;
 }
 
 void SslHmacChannelAuthenticator::OnConnected(int result) {
   if (result != net::OK) {
     LOG(WARNING) << "Failed to establish SSL connection";
     NotifyError(result);
     return;
   }
 
   // Generate authentication digest to write to the socket.
@@ skipping 33 matching lines @@
     if (result == net::ERR_IO_PENDING)
       break;
     if (!HandleAuthBytesWritten(result, callback_called))
       break;
   }
 }
 
 void SslHmacChannelAuthenticator::OnAuthBytesWritten(int result) {
   DCHECK(CalledOnValidThread());
 
-  if (HandleAuthBytesWritten(result, NULL))
-    WriteAuthenticationBytes(NULL);
+  if (HandleAuthBytesWritten(result, nullptr))
+    WriteAuthenticationBytes(nullptr);
 }
 
 bool SslHmacChannelAuthenticator::HandleAuthBytesWritten(
     int result, bool* callback_called) {
   if (result <= 0) {
     LOG(ERROR) << "Error writing authentication: " << result;
     if (callback_called)
       *callback_called = false;
     NotifyError(result);
     return false;
   }
 
   auth_write_buf_->DidConsume(result);
   if (auth_write_buf_->BytesRemaining() > 0)
     return true;
 
-  auth_write_buf_ = NULL;
+  auth_write_buf_ = nullptr;
   CheckDone(callback_called);
   return false;
 }
 
 void SslHmacChannelAuthenticator::ReadAuthenticationBytes() {
   while (true) {
     int result =
         socket_->Read(auth_read_buf_.get(),
                       auth_read_buf_->RemainingCapacity(),
                       base::Bind(&SslHmacChannelAuthenticator::OnAuthBytesRead,
@@ skipping 23 matching lines @@
     return true;
 
   if (!VerifyAuthBytes(std::string(
           auth_read_buf_->StartOfBuffer(),
           auth_read_buf_->StartOfBuffer() + kAuthDigestLength))) {
     LOG(WARNING) << "Mismatched authentication";
     NotifyError(net::ERR_FAILED);
     return false;
   }
 
-  auth_read_buf_ = NULL;
-  CheckDone(NULL);
+  auth_read_buf_ = nullptr;
+  CheckDone(nullptr);
   return false;
 }
 
 bool SslHmacChannelAuthenticator::VerifyAuthBytes(
     const std::string& received_auth_bytes) {
   DCHECK(received_auth_bytes.length() == kAuthDigestLength);
 
   // Compute expected auth bytes.
   std::string auth_bytes = GetAuthBytes(
       socket_.get(), is_ssl_server() ?
       kClientAuthSslExporterLabel : kHostAuthSslExporterLabel, auth_key_);
   if (auth_bytes.empty())
     return false;
 
   return crypto::SecureMemEqual(received_auth_bytes.data(),
                                 &(auth_bytes[0]), kAuthDigestLength);
 }
 
 void SslHmacChannelAuthenticator::CheckDone(bool* callback_called) {
-  if (auth_write_buf_.get() == NULL && auth_read_buf_.get() == NULL) {
-    DCHECK(socket_.get() != NULL);
+  if (auth_write_buf_.get() == nullptr && auth_read_buf_.get() == nullptr) {
+    DCHECK(socket_.get() != nullptr);
     if (callback_called)
       *callback_called = true;
 
     CallDoneCallback(net::OK, socket_.Pass());
   }
 }
 
 void SslHmacChannelAuthenticator::NotifyError(int error) {
   CallDoneCallback(error, nullptr);
 }
 
 void SslHmacChannelAuthenticator::CallDoneCallback(
     int error,
     scoped_ptr<net::StreamSocket> socket) {
   DoneCallback callback = done_callback_;
   done_callback_.Reset();
   callback.Run(error, socket.Pass());
 }
 
 }  // namespace protocol
 }  // namespace remoting