replace NULL->nullptr in src/remoting.

remoting/host/token_validator_base.cc

 // Copyright 2014 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/token_validator_base.h"
 
 #include "base/base64.h"
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/json/json_reader.h"
@@ skipping 104 matching lines @@
   net::ClientCertStore* client_cert_store;
 #if defined(USE_NSS)
   client_cert_store = new net::ClientCertStoreNSS(
       net::ClientCertStoreNSS::PasswordDelegateFactory());
 #elif defined(OS_WIN)
   client_cert_store = new net::ClientCertStoreWin();
 #elif defined(OS_MACOSX)
   client_cert_store = new net::ClientCertStoreMac();
 #elif defined(USE_OPENSSL)
     // OpenSSL does not use the ClientCertStore infrastructure.
-  client_cert_store = NULL;
+  client_cert_store = nullptr;
 #else
 #error Unknown platform.
 #endif
   // The callback is uncancellable, and GetClientCert requires selected_certs
   // and client_cert_store to stay alive until the callback is called. So we
   // must give it a WeakPtr for |this|, and ownership of the other parameters.
   net::CertificateList* selected_certs(new net::CertificateList());
   client_cert_store->GetClientCerts(
       *cert_request_info, selected_certs,
       base::Bind(&TokenValidatorBase::OnCertificatesSelected,
                  weak_factory_.GetWeakPtr(), base::Owned(selected_certs),
                  base::Owned(client_cert_store)));
 }
 
 void TokenValidatorBase::OnCertificatesSelected(
     net::CertificateList* selected_certs,
     net::ClientCertStore* unused) {
   const std::string& issuer =
       third_party_auth_config_.token_validation_cert_issuer;
   if (request_) {
     for (size_t i = 0; i < selected_certs->size(); ++i) {
       if (issuer == kCertIssuerWildCard ||
           issuer == (*selected_certs)[i]->issuer().common_name) {
         request_->ContinueWithCertificate((*selected_certs)[i].get());
         return;
       }
     }
-    request_->ContinueWithCertificate(NULL);
+    request_->ContinueWithCertificate(nullptr);
   }
 }
 
 bool TokenValidatorBase::IsValidScope(const std::string& token_scope) {
   // TODO(rmsousa): Deal with reordering/subsets/supersets/aliases/etc.
   return token_scope == token_scope_;
 }
 
 std::string TokenValidatorBase::ProcessResponse() {
   // Verify that we got a successful response.
@@ skipping 27 matching lines @@
     return std::string();
   }
 
   std::string shared_secret;
   // Everything is valid, so return the shared secret to the caller.
   dict->GetStringWithoutPathExpansion("access_token", &shared_secret);
   return shared_secret;
 }
 
 }  // namespace remoting