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

components/sync/engine/net/http_bridge_unittest.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 "base/bit_cast.h"
 #include "base/run_loop.h"
@@ skipping 21 matching lines @@
 const char kUserAgent[] = "user-agent";
 
 #if defined(OS_ANDROID)
 #define MAYBE_SyncHttpBridgeTest DISABLED_SyncHttpBridgeTest
 #else
 #define MAYBE_SyncHttpBridgeTest SyncHttpBridgeTest
 #endif  // defined(OS_ANDROID)
 class MAYBE_SyncHttpBridgeTest : public testing::Test {
  public:
   MAYBE_SyncHttpBridgeTest()
-      : fake_default_request_context_getter_(NULL),
-        bridge_for_race_test_(NULL),
+      : fake_default_request_context_getter_(nullptr),
+        bridge_for_race_test_(nullptr),
         io_thread_("IO thread") {
     test_server_.AddDefaultHandlers(base::FilePath(kDocRoot));
   }
 
   void SetUp() override {
     base::Thread::Options options;
     options.message_loop_type = base::MessageLoop::TYPE_IO;
     io_thread_.StartWithOptions(options);
   }
 
   void TearDown() override {
     if (fake_default_request_context_getter_) {
       GetIOThreadLoop()->task_runner()->ReleaseSoon(
           FROM_HERE, fake_default_request_context_getter_);
-      fake_default_request_context_getter_ = NULL;
+      fake_default_request_context_getter_ = nullptr;
     }
     io_thread_.Stop();
   }
 
   HttpBridge* BuildBridge() {
     if (!fake_default_request_context_getter_) {
       fake_default_request_context_getter_ =
           new net::TestURLRequestContextGetter(io_thread_.task_runner());
       fake_default_request_context_getter_->AddRef();
     }
@@ skipping 84 matching lines @@
   }
 
  private:
   ~ShuntedHttpBridge() override {}
 
   void CallOnURLFetchComplete() {
     ASSERT_TRUE(
         test_->GetIOThreadLoop()->task_runner()->BelongsToCurrentThread());
     // We return a dummy content response.
     std::string response_content = "success!";
-    net::TestURLFetcher fetcher(0, GURL("http://www.google.com"), NULL);
+    net::TestURLFetcher fetcher(0, GURL("http://www.google.com"), nullptr);
     scoped_refptr<net::HttpResponseHeaders> response_headers(
         new net::HttpResponseHeaders(""));
     fetcher.set_response_code(200);
     fetcher.SetResponseString(response_content);
     fetcher.set_response_headers(response_headers);
     OnURLFetchComplete(&fetcher);
   }
   MAYBE_SyncHttpBridgeTest* test_;
   bool never_finishes_;
 };
 
 void MAYBE_SyncHttpBridgeTest::RunSyncThreadBridgeUseTest(
     base::WaitableEvent* signal_when_created,
     base::WaitableEvent* signal_when_released) {
   scoped_refptr<net::URLRequestContextGetter> ctx_getter(
       new net::TestURLRequestContextGetter(io_thread_.task_runner()));
   {
     scoped_refptr<ShuntedHttpBridge> bridge(
         new ShuntedHttpBridge(ctx_getter.get(), this, true));
     bridge->SetURL("http://www.google.com", 9999);
     bridge->SetPostPayload("text/plain", 2, " ");
     bridge_for_race_test_ = bridge.get();
     signal_when_created->Signal();
 
     int os_error = 0;
     int response_code = 0;
     bridge->MakeSynchronousPost(&os_error, &response_code);
-    bridge_for_race_test_ = NULL;
+    bridge_for_race_test_ = nullptr;
   }
   signal_when_released->Signal();
 }
 
 TEST_F(MAYBE_SyncHttpBridgeTest, TestUsesSameHttpNetworkSession) {
   // Run this test on the IO thread because we can only call
   // URLRequestContextGetter::GetURLRequestContext on the IO thread.
   io_thread()->task_runner()->PostTask(
       FROM_HERE,
       base::Bind(&MAYBE_SyncHttpBridgeTest::TestSameHttpNetworkSession,
@@ skipping 225 matching lines @@
       base::Bind(&base::WaitableEvent::Wait, base::Unretained(&io_waiter))));
 
   signal_when_created.Wait();  // Wait till we have a bridge to abort.
   ASSERT_TRUE(bridge_for_race_test());
 
   // Schedule the fetch completion callback (but don't run it yet). Don't take
   // a reference to the bridge to mimic URLFetcher's handling of the delegate.
   net::URLFetcherDelegate* delegate =
       static_cast<net::URLFetcherDelegate*>(bridge_for_race_test());
   std::string response_content = "success!";
-  net::TestURLFetcher fetcher(0, GURL("http://www.google.com"), NULL);
+  net::TestURLFetcher fetcher(0, GURL("http://www.google.com"), nullptr);
   fetcher.set_response_code(200);
   fetcher.SetResponseString(response_content);
   ASSERT_TRUE(io_thread()->task_runner()->PostTask(
       FROM_HERE, base::Bind(&net::URLFetcherDelegate::OnURLFetchComplete,
                             base::Unretained(delegate), &fetcher)));
 
   // Abort the fetch. This should be smart enough to handle the case where
   // the bridge is destroyed before the callback scheduled above completes.
   bridge_for_race_test()->Abort();
 
@@ skipping 38 matching lines @@
   signal_wait_start->Signal();
   wait_done->Wait();
 }
 
 // Tests RequestContextGetter is properly released on IO thread even when
 // IO thread stops before sync thread.
 TEST_F(MAYBE_SyncHttpBridgeTest, RequestContextGetterReleaseOrder) {
   base::Thread sync_thread("SyncThread");
   sync_thread.Start();
 
-  HttpPostProviderFactory* factory = NULL;
-  HttpPostProviderInterface* bridge = NULL;
+  HttpPostProviderFactory* factory = nullptr;
+  HttpPostProviderInterface* bridge = nullptr;
 
   scoped_refptr<net::URLRequestContextGetter> baseline_context_getter(
       new net::TestURLRequestContextGetter(io_thread()->task_runner()));
 
   base::WaitableEvent signal_when_created(
       base::WaitableEvent::ResetPolicy::AUTOMATIC,
       base::WaitableEvent::InitialState::NOT_SIGNALED);
   base::WaitableEvent wait_for_shutdown(
       base::WaitableEvent::ResetPolicy::AUTOMATIC,
       base::WaitableEvent::InitialState::NOT_SIGNALED);
@@ skipping 21 matching lines @@
       base::WaitableEvent::InitialState::NOT_SIGNALED);
   base::WaitableEvent wait_done(
       base::WaitableEvent::ResetPolicy::AUTOMATIC,
       base::WaitableEvent::InitialState::NOT_SIGNALED);
   io_thread()->task_runner()->PostTask(
       FROM_HERE, base::Bind(&WaitOnIOThread, &signal_wait_start, &wait_done));
   signal_wait_start.Wait();
   // |baseline_context_getter| should have only one reference from local
   // variable.
   EXPECT_TRUE(baseline_context_getter->HasOneRef());
-  baseline_context_getter = NULL;
+  baseline_context_getter = nullptr;
 
   // Unblock and stop IO thread before sync thread.
   wait_done.Signal();
   io_thread()->Stop();
 
   // Unblock and stop sync thread.
   wait_for_shutdown.Signal();
   sync_thread.Stop();
 }
 
@@ skipping 19 matching lines @@
 
   // Sync thread: Finally run the posted task, only to find that our
   // HttpBridgeFactory has been neutered.  Should not crash.
   factory->Init("TestUserAgent", BindToTrackerCallback());
 
   // At this point, attempting to use the factory would trigger a crash.  Both
   // this test and the real world code should make sure this never happens.
 }
 
 }  // namespace syncer