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

cc/layers/layer_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/layers/layer.h"
 
 #include "cc/animation/keyframed_animation_curve.h"
 #include "cc/base/math_util.h"
 #include "cc/layers/layer_impl.h"
 #include "cc/resources/layer_painter.h"
@@ skipping 22 matching lines @@
     code_to_test;                                                           \
     Mock::VerifyAndClearExpectations(layer_tree_host_.get());               \
   } while (false)
 
 namespace cc {
 namespace {
 
 class MockLayerTreeHost : public LayerTreeHost {
  public:
   explicit MockLayerTreeHost(FakeLayerTreeHostClient* client)
-      : LayerTreeHost(client, NULL, LayerTreeSettings()) {
+      : LayerTreeHost(client, nullptr, LayerTreeSettings()) {
     InitializeSingleThreaded(client, base::MessageLoopProxy::current());
   }
 
   MOCK_METHOD0(SetNeedsCommit, void());
   MOCK_METHOD0(SetNeedsUpdateLayers, void());
   MOCK_METHOD0(SetNeedsFullTreeSync, void());
 };
 
 class MockLayerPainter : public LayerPainter {
  public:
   virtual void Paint(SkCanvas* canvas, const gfx::Rect& content_rect) override {
   }
 };
 
 class LayerTest : public testing::Test {
  public:
   LayerTest()
       : host_impl_(&proxy_, &shared_bitmap_manager_),
         fake_client_(FakeLayerTreeHostClient::DIRECT_3D) {}
 
  protected:
   virtual void SetUp() override {
     layer_tree_host_.reset(new StrictMock<MockLayerTreeHost>(&fake_client_));
   }
 
   virtual void TearDown() override {
     Mock::VerifyAndClearExpectations(layer_tree_host_.get());
     EXPECT_CALL(*layer_tree_host_, SetNeedsFullTreeSync()).Times(AnyNumber());
-    parent_ = NULL;
-    child1_ = NULL;
-    child2_ = NULL;
-    child3_ = NULL;
-    grand_child1_ = NULL;
-    grand_child2_ = NULL;
-    grand_child3_ = NULL;
+    parent_ = nullptr;
+    child1_ = nullptr;
+    child2_ = nullptr;
+    child3_ = nullptr;
+    grand_child1_ = nullptr;
+    grand_child2_ = nullptr;
+    grand_child3_ = nullptr;
 
-    layer_tree_host_->SetRootLayer(NULL);
+    layer_tree_host_->SetRootLayer(nullptr);
     layer_tree_host_ = nullptr;
   }
 
   void VerifyTestTreeInitialState() const {
     ASSERT_EQ(3U, parent_->children().size());
     EXPECT_EQ(child1_, parent_->children()[0]);
     EXPECT_EQ(child2_, parent_->children()[1]);
     EXPECT_EQ(child3_, parent_->children()[2]);
     EXPECT_EQ(parent_.get(), child1_->parent());
     EXPECT_EQ(parent_.get(), child2_->parent());
@@ skipping 53 matching lines @@
 
 TEST_F(LayerTest, BasicCreateAndDestroy) {
   scoped_refptr<Layer> test_layer = Layer::Create();
   ASSERT_TRUE(test_layer.get());
 
   EXPECT_CALL(*layer_tree_host_, SetNeedsCommit()).Times(0);
   test_layer->SetLayerTreeHost(layer_tree_host_.get());
   Mock::VerifyAndClearExpectations(layer_tree_host_.get());
 
   EXPECT_CALL(*layer_tree_host_, SetNeedsCommit()).Times(0);
-  test_layer->SetLayerTreeHost(NULL);
+  test_layer->SetLayerTreeHost(nullptr);
 }
 
 TEST_F(LayerTest, AddAndRemoveChild) {
   scoped_refptr<Layer> parent = Layer::Create();
   scoped_refptr<Layer> child = Layer::Create();
 
   // Upon creation, layers should not have children or parent.
   ASSERT_EQ(0U, parent->children().size());
   EXPECT_FALSE(child->parent());
 
@@ skipping 62 matching lines @@
   // Case 4: inserting to end of list
   EXPECT_SET_NEEDS_FULL_TREE_SYNC(1, parent->InsertChild(child4, 3));
 
   ASSERT_EQ(4U, parent->children().size());
   EXPECT_EQ(child1, parent->children()[0]);
   EXPECT_EQ(child2, parent->children()[1]);
   EXPECT_EQ(child3, parent->children()[2]);
   EXPECT_EQ(child4, parent->children()[3]);
   EXPECT_EQ(parent.get(), child4->parent());
 
-  EXPECT_SET_NEEDS_FULL_TREE_SYNC(1, layer_tree_host_->SetRootLayer(NULL));
+  EXPECT_SET_NEEDS_FULL_TREE_SYNC(1, layer_tree_host_->SetRootLayer(nullptr));
 }
 
 TEST_F(LayerTest, InsertChildPastEndOfList) {
   scoped_refptr<Layer> parent = Layer::Create();
   scoped_refptr<Layer> child1 = Layer::Create();
   scoped_refptr<Layer> child2 = Layer::Create();
 
   ASSERT_EQ(0U, parent->children().size());
 
   // insert to an out-of-bounds index
@@ skipping 28 matching lines @@
 
   // Inserting the same child again should cause the child to be removed and
   // re-inserted at the new location.
   EXPECT_SET_NEEDS_FULL_TREE_SYNC(AtLeast(1), parent->InsertChild(child1, 1));
 
   // child1 should now be at the end of the list.
   ASSERT_EQ(2U, parent->children().size());
   EXPECT_EQ(child2, parent->children()[0]);
   EXPECT_EQ(child1, parent->children()[1]);
 
-  EXPECT_SET_NEEDS_FULL_TREE_SYNC(1, layer_tree_host_->SetRootLayer(NULL));
+  EXPECT_SET_NEEDS_FULL_TREE_SYNC(1, layer_tree_host_->SetRootLayer(nullptr));
 }
 
 TEST_F(LayerTest, ReplaceChildWithNewChild) {
   CreateSimpleTestTree();
   scoped_refptr<Layer> child4 = Layer::Create();
 
   EXPECT_FALSE(child4->parent());
 
   EXPECT_SET_NEEDS_FULL_TREE_SYNC(
       AtLeast(1), parent_->ReplaceChild(child2_.get(), child4));
@@ skipping 53 matching lines @@
   ASSERT_EQ(2U, parent->children().size());
   EXPECT_EQ(child1, parent->children()[0]);
   EXPECT_EQ(child2, parent->children()[1]);
 
   EXPECT_SET_NEEDS_COMMIT(2, child1->SetScrollParent(child2.get()));
 
   EXPECT_SET_NEEDS_FULL_TREE_SYNC(1, child2->RemoveFromParent());
 
   child1->reset_needs_push_properties_for_testing();
 
-  EXPECT_SET_NEEDS_COMMIT(1, child2 = NULL);
+  EXPECT_SET_NEEDS_COMMIT(1, child2 = nullptr);
 
   EXPECT_TRUE(child1->needs_push_properties());
 
-  EXPECT_SET_NEEDS_FULL_TREE_SYNC(1, layer_tree_host_->SetRootLayer(NULL));
+  EXPECT_SET_NEEDS_FULL_TREE_SYNC(1, layer_tree_host_->SetRootLayer(nullptr));
 }
 
 TEST_F(LayerTest, DeleteRemovedScrollChild) {
   scoped_refptr<Layer> parent = Layer::Create();
   scoped_refptr<Layer> child1 = Layer::Create();
   scoped_refptr<Layer> child2 = Layer::Create();
 
   EXPECT_SET_NEEDS_FULL_TREE_SYNC(1, layer_tree_host_->SetRootLayer(parent));
 
   ASSERT_EQ(0U, parent->children().size());
 
   EXPECT_SET_NEEDS_FULL_TREE_SYNC(1, parent->InsertChild(child1, 0));
   EXPECT_SET_NEEDS_FULL_TREE_SYNC(1, parent->InsertChild(child2, 1));
 
   ASSERT_EQ(2U, parent->children().size());
   EXPECT_EQ(child1, parent->children()[0]);
   EXPECT_EQ(child2, parent->children()[1]);
 
   EXPECT_SET_NEEDS_COMMIT(2, child1->SetScrollParent(child2.get()));
 
   EXPECT_SET_NEEDS_FULL_TREE_SYNC(1, child1->RemoveFromParent());
 
   child2->reset_needs_push_properties_for_testing();
 
-  EXPECT_SET_NEEDS_COMMIT(1, child1 = NULL);
+  EXPECT_SET_NEEDS_COMMIT(1, child1 = nullptr);
 
   EXPECT_TRUE(child2->needs_push_properties());
 
-  EXPECT_SET_NEEDS_FULL_TREE_SYNC(1, layer_tree_host_->SetRootLayer(NULL));
+  EXPECT_SET_NEEDS_FULL_TREE_SYNC(1, layer_tree_host_->SetRootLayer(nullptr));
 }
 
 TEST_F(LayerTest, ReplaceChildWithSameChild) {
   CreateSimpleTestTree();
 
   // SetNeedsFullTreeSync / SetNeedsCommit should not be called because its the
   // same child.
   EXPECT_CALL(*layer_tree_host_, SetNeedsCommit()).Times(0);
   EXPECT_CALL(*layer_tree_host_, SetNeedsFullTreeSync()).Times(0);
   parent_->ReplaceChild(child2_.get(), child2_);
@@ skipping 33 matching lines @@
   EXPECT_SET_NEEDS_FULL_TREE_SYNC(
       1, layer_tree_host_->SetRootLayer(new_parent));
 
   EXPECT_SET_NEEDS_FULL_TREE_SYNC(
       AtLeast(1), new_parent->SetChildren(new_children));
 
   ASSERT_EQ(2U, new_parent->children().size());
   EXPECT_EQ(new_parent.get(), child1->parent());
   EXPECT_EQ(new_parent.get(), child2->parent());
 
-  EXPECT_SET_NEEDS_FULL_TREE_SYNC(1, layer_tree_host_->SetRootLayer(NULL));
+  EXPECT_SET_NEEDS_FULL_TREE_SYNC(1, layer_tree_host_->SetRootLayer(nullptr));
 }
 
 TEST_F(LayerTest, HasAncestor) {
   scoped_refptr<Layer> parent = Layer::Create();
   EXPECT_FALSE(parent->HasAncestor(parent.get()));
 
   scoped_refptr<Layer> child = Layer::Create();
   parent->AddChild(child);
 
   EXPECT_FALSE(child->HasAncestor(child.get()));
@@ skipping 380 matching lines @@
   child->SetMaskLayer(mask.get());
   child->SetReplicaLayer(replica.get());
   replica->SetMaskLayer(replica_mask.get());
 
   EXPECT_EQ(parent.get(), child->parent());
   EXPECT_EQ(child.get(), mask->parent());
   EXPECT_EQ(child.get(), replica->parent());
   EXPECT_EQ(replica.get(), replica_mask->parent());
 
   replica->SetMaskLayer(replica_mask_replacement.get());
-  EXPECT_EQ(NULL, replica_mask->parent());
+  EXPECT_EQ(nullptr, replica_mask->parent());
   EXPECT_EQ(replica.get(), replica_mask_replacement->parent());
 
   child->SetMaskLayer(mask_replacement.get());
-  EXPECT_EQ(NULL, mask->parent());
+  EXPECT_EQ(nullptr, mask->parent());
   EXPECT_EQ(child.get(), mask_replacement->parent());
 
   child->SetReplicaLayer(replica_replacement.get());
-  EXPECT_EQ(NULL, replica->parent());
+  EXPECT_EQ(nullptr, replica->parent());
   EXPECT_EQ(child.get(), replica_replacement->parent());
 
   EXPECT_EQ(replica.get(), replica->mask_layer()->parent());
 }
 
 TEST_F(LayerTest, CheckTranformIsInvertible) {
   scoped_refptr<Layer> layer = Layer::Create();
   scoped_ptr<LayerImpl> impl_layer =
       LayerImpl::Create(host_impl_.active_tree(), 1);
   EXPECT_CALL(*layer_tree_host_, SetNeedsFullTreeSync()).Times(1);
@@ skipping 104 matching lines @@
   scoped_refptr<Layer> replica = Layer::Create();
   scoped_refptr<Layer> replica_mask = Layer::Create();
 
   // Set up a detached tree of layers. The host pointer should be nil for these
   // layers.
   parent->AddChild(child);
   child->SetMaskLayer(mask.get());
   child->SetReplicaLayer(replica.get());
   replica->SetMaskLayer(replica_mask.get());
 
-  AssertLayerTreeHostMatchesForSubtree(parent.get(), NULL);
+  AssertLayerTreeHostMatchesForSubtree(parent.get(), nullptr);
 
   LayerTreeHostFactory factory;
   scoped_ptr<LayerTreeHost> layer_tree_host = factory.Create();
   // Setting the root layer should set the host pointer for all layers in the
   // tree.
   layer_tree_host->SetRootLayer(parent.get());
 
   AssertLayerTreeHostMatchesForSubtree(parent.get(), layer_tree_host.get());
 
   // Clearing the root layer should also clear out the host pointers for all
   // layers in the tree.
-  layer_tree_host->SetRootLayer(NULL);
+  layer_tree_host->SetRootLayer(nullptr);
 
-  AssertLayerTreeHostMatchesForSubtree(parent.get(), NULL);
+  AssertLayerTreeHostMatchesForSubtree(parent.get(), nullptr);
 }
 
 TEST(LayerLayerTreeHostTest, AddingLayerSubtree) {
   scoped_refptr<Layer> parent = Layer::Create();
   LayerTreeHostFactory factory;
   scoped_ptr<LayerTreeHost> layer_tree_host = factory.Create();
 
   layer_tree_host->SetRootLayer(parent.get());
 
   EXPECT_EQ(parent->layer_tree_host(), layer_tree_host.get());
 
   // Adding a subtree to a layer already associated with a host should set the
   // host pointer on all layers in that subtree.
   scoped_refptr<Layer> child = Layer::Create();
   scoped_refptr<Layer> grand_child = Layer::Create();
   child->AddChild(grand_child);
 
   // Masks, replicas, and replica masks should pick up the new host too.
   scoped_refptr<Layer> child_mask = Layer::Create();
   child->SetMaskLayer(child_mask.get());
   scoped_refptr<Layer> child_replica = Layer::Create();
   child->SetReplicaLayer(child_replica.get());
   scoped_refptr<Layer> child_replica_mask = Layer::Create();
   child_replica->SetMaskLayer(child_replica_mask.get());
 
   parent->AddChild(child);
   AssertLayerTreeHostMatchesForSubtree(parent.get(), layer_tree_host.get());
 
-  layer_tree_host->SetRootLayer(NULL);
+  layer_tree_host->SetRootLayer(nullptr);
 }
 
 TEST(LayerLayerTreeHostTest, ChangeHost) {
   scoped_refptr<Layer> parent = Layer::Create();
   scoped_refptr<Layer> child = Layer::Create();
   scoped_refptr<Layer> mask = Layer::Create();
   scoped_refptr<Layer> replica = Layer::Create();
   scoped_refptr<Layer> replica_mask = Layer::Create();
 
   // Same setup as the previous test.
@@ skipping 10 matching lines @@
                                        first_layer_tree_host.get());
 
   // Now re-root the tree to a new host (simulating what we do on a context lost
   // event). This should update the host pointers for all layers in the tree.
   scoped_ptr<LayerTreeHost> second_layer_tree_host = factory.Create();
   second_layer_tree_host->SetRootLayer(parent.get());
 
   AssertLayerTreeHostMatchesForSubtree(parent.get(),
                                        second_layer_tree_host.get());
 
-  second_layer_tree_host->SetRootLayer(NULL);
+  second_layer_tree_host->SetRootLayer(nullptr);
 }
 
 TEST(LayerLayerTreeHostTest, ChangeHostInSubtree) {
   scoped_refptr<Layer> first_parent = Layer::Create();
   scoped_refptr<Layer> first_child = Layer::Create();
   scoped_refptr<Layer> second_parent = Layer::Create();
   scoped_refptr<Layer> second_child = Layer::Create();
   scoped_refptr<Layer> second_grand_child = Layer::Create();
 
   // First put all children under the first parent and set the first host.
@@ skipping 14 matching lines @@
   second_layer_tree_host->SetRootLayer(second_parent.get());
 
   second_parent->AddChild(second_child);
 
   // The moved layer and its children should point to the new host.
   EXPECT_EQ(second_layer_tree_host.get(), second_child->layer_tree_host());
   EXPECT_EQ(second_layer_tree_host.get(),
             second_grand_child->layer_tree_host());
 
   // Test over, cleanup time.
-  first_layer_tree_host->SetRootLayer(NULL);
-  second_layer_tree_host->SetRootLayer(NULL);
+  first_layer_tree_host->SetRootLayer(nullptr);
+  second_layer_tree_host->SetRootLayer(nullptr);
 }
 
 TEST(LayerLayerTreeHostTest, ReplaceMaskAndReplicaLayer) {
   scoped_refptr<Layer> parent = Layer::Create();
   scoped_refptr<Layer> mask = Layer::Create();
   scoped_refptr<Layer> replica = Layer::Create();
   scoped_refptr<Layer> mask_child = Layer::Create();
   scoped_refptr<Layer> replica_child = Layer::Create();
   scoped_refptr<Layer> mask_replacement = Layer::Create();
   scoped_refptr<Layer> replica_replacement = Layer::Create();
 
   parent->SetMaskLayer(mask.get());
   parent->SetReplicaLayer(replica.get());
   mask->AddChild(mask_child);
   replica->AddChild(replica_child);
 
   LayerTreeHostFactory factory;
   scoped_ptr<LayerTreeHost> layer_tree_host = factory.Create();
   layer_tree_host->SetRootLayer(parent.get());
 
   AssertLayerTreeHostMatchesForSubtree(parent.get(), layer_tree_host.get());
 
   // Replacing the mask should clear out the old mask's subtree's host pointers.
   parent->SetMaskLayer(mask_replacement.get());
-  EXPECT_EQ(NULL, mask->layer_tree_host());
-  EXPECT_EQ(NULL, mask_child->layer_tree_host());
+  EXPECT_EQ(nullptr, mask->layer_tree_host());
+  EXPECT_EQ(nullptr, mask_child->layer_tree_host());
 
   // Same for replacing a replica layer.
   parent->SetReplicaLayer(replica_replacement.get());
-  EXPECT_EQ(NULL, replica->layer_tree_host());
-  EXPECT_EQ(NULL, replica_child->layer_tree_host());
+  EXPECT_EQ(nullptr, replica->layer_tree_host());
+  EXPECT_EQ(nullptr, replica_child->layer_tree_host());
 
   // Test over, cleanup time.
-  layer_tree_host->SetRootLayer(NULL);
+  layer_tree_host->SetRootLayer(nullptr);
 }
 
 TEST(LayerLayerTreeHostTest, DestroyHostWithNonNullRootLayer) {
   scoped_refptr<Layer> root = Layer::Create();
   scoped_refptr<Layer> child = Layer::Create();
   root->AddChild(child);
   LayerTreeHostFactory factory;
   scoped_ptr<LayerTreeHost> layer_tree_host = factory.Create();
   layer_tree_host->SetRootLayer(root);
 }
@@ skipping 109 matching lines @@
   root_layer->AddChild(becomes_not_draws_content);
   EXPECT_EQ(0, root_layer->NumDescendantsThatDrawContent());
 
   becomes_draws_content->SetIsDrawable(true);
   root_layer->AddChild(becomes_draws_content);
   EXPECT_EQ(1, root_layer->NumDescendantsThatDrawContent());
 }
 
 }  // namespace
 }  // namespace cc