[Sync] Replacing NULL with nullptr in code and null in comments for components/sync/

components/sync/engine_impl/net/server_connection_manager.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 "components/sync/engine_impl/net/server_connection_manager.h"
 
 #include <errno.h>
 
 #include <ostream>
 #include <vector>
@@ skipping 140 matching lines @@
     const string& server,
     int port,
     bool use_ssl,
     CancelationSignal* cancelation_signal)
     : sync_server_(server),
       sync_server_port_(port),
       use_ssl_(use_ssl),
       proto_sync_path_(kSyncServerSyncPath),
       server_status_(HttpResponse::NONE),
       terminated_(false),
-      active_connection_(NULL),
+      active_connection_(nullptr),
       cancelation_signal_(cancelation_signal),
       signal_handler_registered_(false) {
   signal_handler_registered_ = cancelation_signal_->TryRegisterHandler(this);
   if (!signal_handler_registered_) {
     // Calling a virtual function from a constructor.  We can get away with it
     // here because ServerConnectionManager::OnSignalReceived() is the function
     // we want to call.
     OnSignalReceived();
   }
 }
 
 ServerConnectionManager::~ServerConnectionManager() {
   if (signal_handler_registered_) {
     cancelation_signal_->UnregisterHandler(this);
   }
 }
 
 ServerConnectionManager::Connection*
 ServerConnectionManager::MakeActiveConnection() {
   base::AutoLock lock(terminate_connection_lock_);
   DCHECK(!active_connection_);
   if (terminated_)
-    return NULL;
+    return nullptr;
 
   active_connection_ = MakeConnection();
   return active_connection_;
 }
 
 void ServerConnectionManager::OnConnectionDestroyed(Connection* connection) {
   DCHECK(connection);
   base::AutoLock lock(terminate_connection_lock_);
-  // |active_connection_| can be NULL already if it was aborted. Also,
+  // |active_connection_| can be null already if it was aborted. Also,
   // it can legitimately be a different Connection object if a new Connection
   // was created after a previous one was Aborted and destroyed.
   if (active_connection_ != connection)
     return;
 
-  active_connection_ = NULL;
+  active_connection_ = nullptr;
 }
 
 bool ServerConnectionManager::SetAuthToken(const std::string& auth_token) {
   DCHECK(thread_checker_.CalledOnValidThread());
   if (previously_invalidated_token != auth_token) {
     auth_token_.assign(auth_token);
     previously_invalidated_token = std::string();
     return true;
   }
 
@@ skipping 95 matching lines @@
   listeners_.AddObserver(listener);
 }
 
 void ServerConnectionManager::RemoveListener(
     ServerConnectionEventListener* listener) {
   DCHECK(thread_checker_.CalledOnValidThread());
   listeners_.RemoveObserver(listener);
 }
 
 ServerConnectionManager::Connection* ServerConnectionManager::MakeConnection() {
-  return NULL;  // For testing.
+  return nullptr;  // For testing.
 }
 
 void ServerConnectionManager::OnSignalReceived() {
   base::AutoLock lock(terminate_connection_lock_);
   terminated_ = true;
   if (active_connection_)
     active_connection_->Abort();
 
   // Sever our ties to this connection object. Note that it still may exist,
   // since we don't own it, but it has been neutered.
-  active_connection_ = NULL;
+  active_connection_ = nullptr;
 }
 
 std::ostream& operator<<(std::ostream& s, const struct HttpResponse& hr) {
   s << " Response Code (bogus on error): " << hr.response_code;
   s << " Content-Length (bogus on error): " << hr.content_length;
   s << " Server Status: "
     << HttpResponse::GetServerConnectionCodeString(hr.server_status);
   return s;
 }
 
 }  // namespace syncer