Add a std::nullptr_t constructor to base::WeakPtr.

base/memory/weak_ptr_unittest.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 "base/memory/weak_ptr.h"
 
 #include <memory>
 #include <string>
 
 #include "base/bind.h"
 #include "base/debug/leak_annotations.h"
 #include "base/location.h"
 #include "base/single_thread_task_runner.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/threading/thread.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace base {
 namespace {
 
+WeakPtr<int> PassThru(WeakPtr<int> ptr) {
+  return ptr;
+}
+
 template <class T>
 class OffThreadObjectCreator {
  public:
   static T* NewObject() {
     T* result;
     {
       Thread creator_thread("creator_thread");
       creator_thread.Start();
       creator_thread.task_runner()->PostTask(
           FROM_HERE, base::Bind(OffThreadObjectCreator::CreateObject, &result));
@@ skipping 76 matching lines @@
   void DeleteArrow(Arrow* object) {
     WaitableEvent completion(true, false);
     task_runner()->PostTask(
         FROM_HERE,
         base::Bind(&BackgroundThread::DoDeleteArrow, object, &completion));
     completion.Wait();
   }
 
   Target* DeRef(const Arrow* arrow) {
     WaitableEvent completion(true, false);
-    Target* result = NULL;
+    Target* result = nullptr;
     task_runner()->PostTask(FROM_HERE, base::Bind(&BackgroundThread::DoDeRef,
                                                   arrow, &result, &completion));
     completion.Wait();
     return result;
   }
 
  protected:
   static void DoCreateArrowFromArrow(Arrow** arrow,
                                      const Arrow* other,
                                      WaitableEvent* completion) {
@@ skipping 59 matching lines @@
 TEST(WeakPtrFactoryTest, Comparison) {
   int data;
   WeakPtrFactory<int> factory(&data);
   WeakPtr<int> ptr = factory.GetWeakPtr();
   WeakPtr<int> ptr2 = ptr;
   EXPECT_EQ(ptr.get(), ptr2.get());
 }
 
 TEST(WeakPtrFactoryTest, OutOfScope) {
   WeakPtr<int> ptr;
-  EXPECT_EQ(NULL, ptr.get());
+  EXPECT_EQ(nullptr, ptr.get());
   {
     int data;
     WeakPtrFactory<int> factory(&data);
     ptr = factory.GetWeakPtr();
   }
-  EXPECT_EQ(NULL, ptr.get());
+  EXPECT_EQ(nullptr, ptr.get());
 }
 
 TEST(WeakPtrFactoryTest, Multiple) {
   WeakPtr<int> a, b;
   {
     int data;
     WeakPtrFactory<int> factory(&data);
     a = factory.GetWeakPtr();
     b = factory.GetWeakPtr();
     EXPECT_EQ(&data, a.get());
     EXPECT_EQ(&data, b.get());
   }
-  EXPECT_EQ(NULL, a.get());
-  EXPECT_EQ(NULL, b.get());
+  EXPECT_EQ(nullptr, a.get());
+  EXPECT_EQ(nullptr, b.get());
 }
 
 TEST(WeakPtrFactoryTest, MultipleStaged) {
   WeakPtr<int> a;
   {
     int data;
     WeakPtrFactory<int> factory(&data);
     a = factory.GetWeakPtr();
     {
       WeakPtr<int> b = factory.GetWeakPtr();
     }
-    EXPECT_TRUE(NULL != a.get());
+    EXPECT_NE(nullptr, a.get());
   }
-  EXPECT_EQ(NULL, a.get());
+  EXPECT_EQ(nullptr, a.get());
 }
 
 TEST(WeakPtrFactoryTest, Dereference) {
   Base data;
   data.member = "123456";
   WeakPtrFactory<Base> factory(&data);
   WeakPtr<Base> ptr = factory.GetWeakPtr();
   EXPECT_EQ(&data, ptr.get());
   EXPECT_EQ(data.member, (*ptr).member);
   EXPECT_EQ(data.member, ptr->member);
 }
 
 TEST(WeakPtrFactoryTest, UpCast) {
   Derived data;
   WeakPtrFactory<Derived> factory(&data);
   WeakPtr<Base> ptr = factory.GetWeakPtr();
   ptr = factory.GetWeakPtr();
   EXPECT_EQ(ptr.get(), &data);
 }
 
+TEST(WeakPtrTest, ConstructFromNullptr) {
+  WeakPtr<int> ptr = PassThru(nullptr);
+  EXPECT_EQ(nullptr, ptr.get());
+}
+
 TEST(WeakPtrTest, SupportsWeakPtr) {
   Target target;
   WeakPtr<Target> ptr = target.AsWeakPtr();
   EXPECT_EQ(&target, ptr.get());
 }
 
 TEST(WeakPtrTest, DerivedTarget) {
   DerivedTarget target;
   WeakPtr<DerivedTarget> ptr = AsWeakPtr(&target);
   EXPECT_EQ(&target, ptr.get());
@@ skipping 30 matching lines @@
   }
 }
 
 TEST(WeakPtrTest, InvalidateWeakPtrs) {
   int data;
   WeakPtrFactory<int> factory(&data);
   WeakPtr<int> ptr = factory.GetWeakPtr();
   EXPECT_EQ(&data, ptr.get());
   EXPECT_TRUE(factory.HasWeakPtrs());
   factory.InvalidateWeakPtrs();
-  EXPECT_EQ(NULL, ptr.get());
+  EXPECT_EQ(nullptr, ptr.get());
   EXPECT_FALSE(factory.HasWeakPtrs());
 
   // Test that the factory can create new weak pointers after a
   // InvalidateWeakPtrs call, and they remain valid until the next
   // InvalidateWeakPtrs call.
   WeakPtr<int> ptr2 = factory.GetWeakPtr();
   EXPECT_EQ(&data, ptr2.get());
   EXPECT_TRUE(factory.HasWeakPtrs());
   factory.InvalidateWeakPtrs();
-  EXPECT_EQ(NULL, ptr2.get());
+  EXPECT_EQ(nullptr, ptr2.get());
   EXPECT_FALSE(factory.HasWeakPtrs());
 }
 
 TEST(WeakPtrTest, HasWeakPtrs) {
   int data;
   WeakPtrFactory<int> factory(&data);
   {
     WeakPtr<int> ptr = factory.GetWeakPtr();
     EXPECT_TRUE(factory.HasWeakPtrs());
   }
@@ skipping 86 matching lines @@
   background.Start();
 
   Arrow arrow;
   std::unique_ptr<TargetWithFactory> target(new TargetWithFactory);
 
   // Bind to main thread.
   arrow.target = target->factory.GetWeakPtr();
   EXPECT_EQ(target.get(), arrow.target.get());
 
   target->factory.InvalidateWeakPtrs();
-  EXPECT_EQ(NULL, arrow.target.get());
+  EXPECT_EQ(nullptr, arrow.target.get());
 
   arrow.target = target->factory.GetWeakPtr();
   // Re-bind to background thread.
   EXPECT_EQ(target.get(), background.DeRef(&arrow));
 
   // And the background thread can now delete the target.
   background.DeleteTarget(target.release());
 }
 
 TEST(WeakPtrTest, MainThreadRefOutlivesBackgroundThreadRef) {
@@ skipping 42 matching lines @@
   // - WeakPtr gets destroyed on Thread B
   BackgroundThread background;
   background.Start();
   Arrow* arrow_copy;
   {
     Target target;
     Arrow arrow;
     arrow.target = target.AsWeakPtr();
     background.CreateArrowFromArrow(&arrow_copy, &arrow);
   }
-  EXPECT_EQ(NULL, arrow_copy->target.get());
+  EXPECT_EQ(nullptr, arrow_copy->target.get());
   background.DeleteArrow(arrow_copy);
 }
 
 TEST(WeakPtrTest, NonOwnerThreadCanCopyAndAssignWeakPtr) {
   // Main thread creates a Target object.
   Target target;
   // Main thread creates an arrow referencing the Target.
   Arrow *arrow = new Arrow();
   arrow->target = target.AsWeakPtr();
 
@@ skipping 140 matching lines @@
   background.Start();
   background.DeleteTarget(target.release());
 
   // Main thread attempts to dereference the target, violating thread binding.
   ASSERT_DEATH(arrow.target.get(), "");
 }
 
 #endif
 
 }  // namespace base