[C++11 Allowed Features] Declares a type-safe null pointer converting from NULL to nullptr [part-…

cc/trees/layer_tree_host_unittest_delegated.cc

 // Copyright 2013 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 "cc/trees/layer_tree_host.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/location.h"
@@ skipping 257 matching lines @@
     RenderPass* root_pass = frame_data->render_pass_list.back();
     gfx::Size frame_size = root_pass->output_rect.size();
 
     if (frame_provider_.get() && frame_size == frame_provider_->frame_size()) {
       frame_provider_->SetFrameData(frame_data.Pass());
       return;
     }
 
     if (delegated_.get()) {
       delegated_->RemoveFromParent();
-      delegated_ = NULL;
-      frame_provider_ = NULL;
+      delegated_ = nullptr;
+      frame_provider_ = nullptr;
     }
 
     frame_provider_ = new DelegatedFrameProvider(resource_collection_.get(),
                                                  frame_data.Pass());
 
     delegated_ = CreateDelegatedLayer(frame_provider_.get());
   }
 
   scoped_refptr<DelegatedRendererLayer> CreateDelegatedLayer(
       DelegatedFrameProvider* frame_provider) {
     scoped_refptr<DelegatedRendererLayer> delegated =
         FakeDelegatedRendererLayer::Create(frame_provider);
     delegated->SetBounds(gfx::Size(10, 10));
     delegated->SetIsDrawable(true);
 
     root_->AddChild(delegated);
     return delegated;
   }
 
-  virtual void AfterTest() override { resource_collection_->SetClient(NULL); }
+  virtual void AfterTest() override { resource_collection_->SetClient(nullptr); }

[danakj, 2014/10/09 16:00:53]

and here

 
   // DelegatedFrameProviderClient implementation.
   virtual void UnusedResourcesAreAvailable() override { available_ = true; }
 
   bool TestAndResetAvailable() {
     bool available = available_;
     available_ = false;
     return available;
   }
 
@@ skipping 1580 matching lines @@
 
         frame = CreateFrameData(gfx::Rect(0, 0, 1, 1), gfx::Rect(0, 0, 1, 1));
         AddTextureQuad(frame.get(), 999);
         AddTransferableResource(frame.get(), 999);
         AddTextureQuad(frame.get(), 555);
         AddTransferableResource(frame.get(), 555);
 
         // Remove the delegated layer and replace it with a new one. Make a new
         // frame but with the same resources for it.
         delegated_->RemoveFromParent();
-        delegated_ = NULL;
+        delegated_ = nullptr;
 
         frame_provider_->SetFrameData(frame.Pass());
         delegated_ = CreateDelegatedLayer(frame_provider_.get());
         break;
       case 3:
         resource_collection_->TakeUnusedResourcesForChildCompositor(&resources);
         EXPECT_EQ(0u, resources.size());
         EXPECT_FALSE(TestAndResetAvailable());
 
         // Use a frame with no resources in it.
@@ skipping 44 matching lines @@
         // Create a DelegatedRendererLayer using the frame.
         SetFrameData(frame.Pass());
         break;
       case 2:
         // Create a second DelegatedRendererLayer using the same frame provider.
         delegated_thief_ = CreateDelegatedLayer(frame_provider_.get());
         root_->AddChild(delegated_thief_);
 
         // And drop our ref on the frame provider so only the layers keep it
         // alive.
-        frame_provider_ = NULL;
+        frame_provider_ = nullptr;
         break;
       case 3:
         resource_collection_->TakeUnusedResourcesForChildCompositor(&resources);
         EXPECT_EQ(0u, resources.size());
         EXPECT_FALSE(TestAndResetAvailable());
 
         // Remove one delegated layer from the tree. No resources should be
         // returned yet.
         delegated_->RemoveFromParent();
         break;
       case 4:
         resource_collection_->TakeUnusedResourcesForChildCompositor(&resources);
         EXPECT_EQ(0u, resources.size());
         EXPECT_FALSE(TestAndResetAvailable());
 
         // Put the first layer back, and remove the other layer and destroy it.
         // No resources should be returned yet.
         root_->AddChild(delegated_);
         delegated_thief_->RemoveFromParent();
-        delegated_thief_ = NULL;
+        delegated_thief_ = nullptr;
         break;
       case 5:
         resource_collection_->TakeUnusedResourcesForChildCompositor(&resources);
         EXPECT_EQ(0u, resources.size());
         EXPECT_FALSE(TestAndResetAvailable());
 
         // Remove the first layer from the tree again. The resources are still
         // held by the main thread layer.
         delegated_->RemoveFromParent();
         break;
       case 6:
         resource_collection_->TakeUnusedResourcesForChildCompositor(&resources);
         EXPECT_EQ(0u, resources.size());
         EXPECT_FALSE(TestAndResetAvailable());
 
         // Destroy the layer and the resources should be returned immediately.
-        delegated_ = NULL;
+        delegated_ = nullptr;
 
         resource_collection_->TakeUnusedResourcesForChildCompositor(&resources);
         {
           unsigned expected[] = {555, 999};
           EXPECT_RESOURCES(expected, resources);
           EXPECT_TRUE(TestAndResetAvailable());
         }
         EndTest();
         break;
     }
@@ skipping 63 matching lines @@
       case 5:
         resource_collection_->TakeUnusedResourcesForChildCompositor(&resources);
         {
           unsigned expected[] = {555, 999};
           EXPECT_RESOURCES(expected, resources);
           EXPECT_TRUE(TestAndResetAvailable());
         }
 
         // Destroy the layer.
         delegated_->RemoveFromParent();
-        delegated_ = NULL;
+        delegated_ = nullptr;
         break;
       case 6:
         resource_collection_->TakeUnusedResourcesForChildCompositor(&resources);
         EXPECT_EQ(0u, resources.size());
         EXPECT_FALSE(TestAndResetAvailable());
 
         // Destroy the frame provider. Resources should be returned.
-        frame_provider_ = NULL;
+        frame_provider_ = nullptr;
 
         resource_collection_->TakeUnusedResourcesForChildCompositor(&resources);
         {
           unsigned expected[] = {777, 888};
           EXPECT_RESOURCES(expected, resources);
           EXPECT_TRUE(TestAndResetAvailable());
         }
         EndTest();
         break;
     }
@@ skipping 54 matching lines @@
 
         resource_collection_->TakeUnusedResourcesForChildCompositor(&resources);
         {
           unsigned expected[] = {555, 999};
           EXPECT_RESOURCES(expected, resources);
           EXPECT_TRUE(TestAndResetAvailable());
           resources.clear();
         }
 
         // Destroy the frame provider.
-        frame_provider_ = NULL;
+        frame_provider_ = nullptr;
 
         resource_collection_->TakeUnusedResourcesForChildCompositor(&resources);
         EXPECT_EQ(0u, resources.size());
         EXPECT_FALSE(TestAndResetAvailable());
 
         // Destroy the layer. Resources should be returned.
-        delegated_ = NULL;
+        delegated_ = nullptr;
 
         resource_collection_->TakeUnusedResourcesForChildCompositor(&resources);
         {
           unsigned expected[] = {777, 888};
           EXPECT_RESOURCES(expected, resources);
           EXPECT_TRUE(TestAndResetAvailable());
         }
         EndTest();
         break;
     }
   }
 
   virtual void SwapBuffersOnThread(LayerTreeHostImpl* host_impl,
                                    bool result) override {
     ReturnUnusedResourcesFromParent(host_impl);
   }
 
   scoped_refptr<DelegatedRendererLayer> delegated_thief_;
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(
     LayerTreeHostDelegatedTestRemoveAndChangeResources);
 
 }  // namespace
 }  // namespace cc