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

components/sync/engine/net/http_bridge.cc

 // Copyright 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/net/http_bridge.h"
 
 #include <stddef.h>
 
 #include <vector>
 
@@ skipping 93 matching lines @@
 }
 
 void HttpBridgeFactory::Destroy(HttpPostProviderInterface* http) {
   static_cast<HttpBridge*>(http)->Release();
 }
 
 void HttpBridgeFactory::OnSignalReceived() {
   base::AutoLock lock(request_context_getter_lock_);
   // Release |request_context_getter_| as soon as possible so that it
   // is destroyed in the right order on its network task runner.
-  request_context_getter_ = NULL;
+  request_context_getter_ = nullptr;
 }
 
 HttpBridge::URLFetchState::URLFetchState()
-    : url_poster(NULL),
+    : url_poster(nullptr),
       aborted(false),
       request_completed(false),
       request_succeeded(false),
       http_response_code(-1),
       error_code(-1) {}
 HttpBridge::URLFetchState::~URLFetchState() {}
 
 HttpBridge::HttpBridge(
     const std::string& user_agent,
     const scoped_refptr<net::URLRequestContextGetter>& context_getter,
@@ skipping 138 matching lines @@
   return fetch_state_.response_content.data();
 }
 
 const std::string HttpBridge::GetResponseHeaderValue(
     const std::string& name) const {
   DCHECK(thread_checker_.CalledOnValidThread());
   base::AutoLock lock(fetch_state_lock_);
   DCHECK(fetch_state_.request_completed);
 
   std::string value;
-  fetch_state_.response_headers->EnumerateHeader(NULL, name, &value);
+  fetch_state_.response_headers->EnumerateHeader(nullptr, name, &value);
   return value;
 }
 
 void HttpBridge::Abort() {
   base::AutoLock lock(fetch_state_lock_);
 
   // Release |request_context_getter_| as soon as possible so that it is
   // destroyed in the right order on its network task runner.
-  request_context_getter_ = NULL;
+  request_context_getter_ = nullptr;
 
   DCHECK(!fetch_state_.aborted);
   if (fetch_state_.aborted || fetch_state_.request_completed)
     return;
 
   fetch_state_.aborted = true;
   if (!network_task_runner_->PostTask(
           FROM_HERE,
           base::Bind(&HttpBridge::DestroyURLFetcherOnIOThread, this,
                      fetch_state_.url_poster,
                      fetch_state_.http_request_timeout_timer.release()))) {
     // Madness ensues.
     NOTREACHED() << "Could not post task to delete URLFetcher";
   }
 
-  fetch_state_.url_poster = NULL;
+  fetch_state_.url_poster = nullptr;
   fetch_state_.error_code = net::ERR_ABORTED;
   http_post_completed_.Signal();
 }
 
 void HttpBridge::DestroyURLFetcherOnIOThread(net::URLFetcher* fetcher,
                                              base::Timer* fetch_timer) {
   DCHECK(network_task_runner_->BelongsToCurrentThread());
   if (fetch_timer)
     delete fetch_timer;
   delete fetcher;
@@ skipping 41 matching lines @@
   int64_t compressed_content_length =
       source->GetReceivedResponseContentLength();
   RecordSyncResponseContentLengthHistograms(compressed_content_length,
                                             original_content_length);
 
   // End of the line for url_poster_. It lives only on the IO loop.
   // We defer deletion because we're inside a callback from a component of the
   // URLFetcher, so it seems most natural / "polite" to let the stack unwind.
   base::ThreadTaskRunnerHandle::Get()->DeleteSoon(FROM_HERE,
                                                   fetch_state_.url_poster);
-  fetch_state_.url_poster = NULL;
+  fetch_state_.url_poster = nullptr;
 
   // Wake the blocked syncer thread in MakeSynchronousPost.
   // WARNING: DONT DO ANYTHING AFTER THIS CALL! |this| may be deleted!
   http_post_completed_.Signal();
 }
 
 void HttpBridge::OnURLFetchDownloadProgress(const net::URLFetcher* source,
                                             int64_t current,
                                             int64_t total,
                                             int64_t current_network_bytes) {
@@ skipping 26 matching lines @@
 
   fetch_state_.end_time = base::Time::Now();
   fetch_state_.request_completed = true;
   fetch_state_.request_succeeded = false;
   fetch_state_.http_response_code = -1;
   fetch_state_.error_code = net::ERR_TIMED_OUT;
 
   // This method is called by the timer, not the url fetcher implementation,
   // so it's safe to delete the fetcher here.
   delete fetch_state_.url_poster;
-  fetch_state_.url_poster = NULL;
+  fetch_state_.url_poster = nullptr;
 
   // Timer is smart enough to handle being deleted as part of the invoked task.
   fetch_state_.http_request_timeout_timer.reset();
 
   // Wake the blocked syncer thread in MakeSynchronousPost.
   // WARNING: DONT DO ANYTHING AFTER THIS CALL! |this| may be deleted!
   http_post_completed_.Signal();
 }
 
 net::URLRequestContextGetter* HttpBridge::GetRequestContextGetterForTest()
     const {
   base::AutoLock lock(fetch_state_lock_);
   return request_context_getter_.get();
 }
 
 void HttpBridge::UpdateNetworkTime() {
   std::string sane_time_str;
   if (!fetch_state_.request_succeeded || fetch_state_.start_time.is_null() ||
       fetch_state_.end_time < fetch_state_.start_time ||
       !fetch_state_.response_headers ||
-      !fetch_state_.response_headers->EnumerateHeader(NULL, "Sane-Time-Millis",
-                                                      &sane_time_str)) {
+      !fetch_state_.response_headers->EnumerateHeader(
+          nullptr, "Sane-Time-Millis", &sane_time_str)) {
     return;
   }
 
   int64_t sane_time_ms = 0;
   if (base::StringToInt64(sane_time_str, &sane_time_ms)) {
     network_time_update_callback_.Run(
         base::Time::FromJsTime(sane_time_ms),
         base::TimeDelta::FromMilliseconds(1),
         fetch_state_.end_time - fetch_state_.start_time);
   }
 }
 
 }  // namespace syncer