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

cc/trees/layer_tree_host_unittest.cc

 // Copyright 2011 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/auto_reset.h"
 #include "base/synchronization/lock.h"
@@ skipping 842 matching lines @@
     Layer* root_layer = layer_tree_host()->root_layer();
     scroll_layer_->SetScrollClipLayerId(root_layer->id());
     scroll_layer_->SetIsContainerForFixedPositionLayers(true);
     scroll_layer_->SetBounds(gfx::Size(2 * root_layer->bounds().width(),
                                        2 * root_layer->bounds().height()));
     scroll_layer_->SetScrollOffset(gfx::ScrollOffset());
     layer_tree_host()->root_layer()->AddChild(scroll_layer_);
     // This test requires the page_scale and inner viewport layers to be
     // identified.
     layer_tree_host()->RegisterViewportLayers(
-        root_layer, scroll_layer_.get(), NULL);
+        root_layer, scroll_layer_.get(), nullptr);
     layer_tree_host()->SetPageScaleFactorAndLimits(1.f, 0.5f, 2.f);
   }
 
   virtual void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
   virtual void ApplyViewportDeltas(const gfx::Vector2d& scroll_delta,
                                    float scale,
                                    float) override {
     gfx::ScrollOffset offset = scroll_layer_->scroll_offset();
     scroll_layer_->SetScrollOffset(ScrollOffsetWithDelta(offset,
@@ skipping 1022 matching lines @@
   int num_complete_commits_;
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostTestDeferCommits);
 
 class LayerTreeHostWithProxy : public LayerTreeHost {
  public:
   LayerTreeHostWithProxy(FakeLayerTreeHostClient* client,
                          const LayerTreeSettings& settings,
                          scoped_ptr<FakeProxy> proxy)
-      : LayerTreeHost(client, NULL, settings) {
+      : LayerTreeHost(client, nullptr, settings) {
     proxy->SetLayerTreeHost(this);
     client->SetLayerTreeHost(this);
     InitializeForTesting(proxy.Pass());
   }
 };
 
 TEST(LayerTreeHostTest, LimitPartialUpdates) {
   // When partial updates are not allowed, max updates should be 0.
   {
     FakeLayerTreeHostClient client(FakeLayerTreeHostClient::DIRECT_3D);
@@ skipping 1372 matching lines @@
         break;
       case 16:
         // Second child is invalidated with SetNeedsDisplay
         ++expected_push_properties_child2_impl_;
 
         // The leaf that always pushed is pushed.
         ++expected_push_properties_grandchild_impl_;
         break;
     }
 
-    PushPropertiesCountingLayerImpl* root_impl_ = NULL;
-    PushPropertiesCountingLayerImpl* child_impl_ = NULL;
-    PushPropertiesCountingLayerImpl* child2_impl_ = NULL;
-    PushPropertiesCountingLayerImpl* grandchild_impl_ = NULL;
-    PushPropertiesCountingLayerImpl* leaf_always_pushing_layer_impl_ = NULL;
+    PushPropertiesCountingLayerImpl* root_impl_ = nullptr;
+    PushPropertiesCountingLayerImpl* child_impl_ = nullptr;
+    PushPropertiesCountingLayerImpl* child2_impl_ = nullptr;
+    PushPropertiesCountingLayerImpl* grandchild_impl_ = nullptr;
+    PushPropertiesCountingLayerImpl* leaf_always_pushing_layer_impl_ = nullptr;
 
     // Pull the layers that we need from the tree assuming the same structure
     // as LayerTreeHostTestLayersPushProperties
     root_impl_ = static_cast<PushPropertiesCountingLayerImpl*>(
         host_impl->RootLayer());
 
     if (root_impl_ && root_impl_->children().size() > 0) {
       child_impl_ = static_cast<PushPropertiesCountingLayerImpl*>(
           root_impl_->children()[0]);
 
@@ skipping 1344 matching lines @@
   virtual void WillBeginMainFrame() override {
     if (TestEnded())
       return;
 
     int set_needs_commit_count = 0;
     int set_needs_redraw_count = 0;
 
     {
       scoped_ptr<SimpleSwapPromiseMonitor> swap_promise_monitor(
           new SimpleSwapPromiseMonitor(layer_tree_host(),
-                                       NULL,
+                                       nullptr,
                                        &set_needs_commit_count,
                                        &set_needs_redraw_count));
       layer_tree_host()->SetNeedsCommit();
       EXPECT_EQ(1, set_needs_commit_count);
       EXPECT_EQ(0, set_needs_redraw_count);
     }
 
     // Now the monitor is destroyed, SetNeedsCommit() is no longer being
     // monitored.
     layer_tree_host()->SetNeedsCommit();
     EXPECT_EQ(1, set_needs_commit_count);
     EXPECT_EQ(0, set_needs_redraw_count);
 
     {
       scoped_ptr<SimpleSwapPromiseMonitor> swap_promise_monitor(
           new SimpleSwapPromiseMonitor(layer_tree_host(),
-                                       NULL,
+                                       nullptr,
                                        &set_needs_commit_count,
                                        &set_needs_redraw_count));
       layer_tree_host()->SetNeedsUpdateLayers();
       EXPECT_EQ(2, set_needs_commit_count);
       EXPECT_EQ(0, set_needs_redraw_count);
     }
 
     {
       scoped_ptr<SimpleSwapPromiseMonitor> swap_promise_monitor(
           new SimpleSwapPromiseMonitor(layer_tree_host(),
-                                       NULL,
+                                       nullptr,
                                        &set_needs_commit_count,
                                        &set_needs_redraw_count));
       layer_tree_host()->SetNeedsAnimate();
       EXPECT_EQ(3, set_needs_commit_count);
       EXPECT_EQ(0, set_needs_redraw_count);
     }
 
     EndTest();
   }
 
@@ skipping 229 matching lines @@
   virtual void AfterTest() override {}
 
   FakeContentLayerClient layer_client_;
 };
 
 MULTI_THREAD_TEST_F(LayerTreeHostTestGpuRasterizationForced);
 
 class LayerTreeHostTestContinuousPainting : public LayerTreeHostTest {
  public:
   LayerTreeHostTestContinuousPainting()
-      : num_commits_(0), num_draws_(0), bounds_(20, 20), child_layer_(NULL) {}
+      : num_commits_(0),
+        num_draws_(0),
+        bounds_(20, 20),
+        child_layer_(nullptr) {}
 
  protected:
   enum { kExpectedNumCommits = 10 };
 
   virtual void SetupTree() override {
     scoped_refptr<Layer> root_layer = Layer::Create();
     root_layer->SetBounds(bounds_);
 
     if (layer_tree_host()->settings().impl_side_painting) {
       picture_layer_ = FakePictureLayer::Create(&client_);
@@ skipping 203 matching lines @@
   }
 
   int commit_count_;
   TestSwapPromiseResult swap_promise_result_[3];
 };
 
 // Impl-side painting is not supported for synchronous compositing.
 SINGLE_THREAD_NOIMPL_TEST_F(LayerTreeHostTestSynchronousCompositeSwapPromise);
 
 }  // namespace cc