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

cc/trees/layer_tree_host_unittest_occlusion.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 "cc/trees/layer_tree_host.h"
 
 #include "cc/layers/layer.h"
 #include "cc/output/copy_output_request.h"
 #include "cc/output/copy_output_result.h"
 #include "cc/test/layer_tree_test.h"
@@ skipping 102 matching lines @@
 };
 
 
 class LayerTreeHostOcclusionTestOcclusionSurfaceClipping
     : public LayerTreeHostOcclusionTest {
  public:
   virtual void SetupTree() override {
     // The child layer is a surface and the grand_child is opaque, but clipped
     // to the child and root
     SetLayerPropertiesForTesting(
-        root_.get(), NULL, identity_matrix_,
+        root_.get(), nullptr, identity_matrix_,
         gfx::PointF(0.f, 0.f), gfx::Size(200, 200), true);
     SetLayerPropertiesForTesting(
         child_.get(), root_.get(), identity_matrix_,
         gfx::PointF(10.f, 10.f), gfx::Size(500, 500), false);
     SetLayerPropertiesForTesting(
         grand_child_.get(), child_.get(), identity_matrix_,
         gfx::PointF(-10.f, -10.f), gfx::Size(20, 500), true);
 
     child_->SetMasksToBounds(true);
     child_->SetForceRenderSurface(true);
 
     child_->set_expected_occlusion(gfx::Rect(0, 0, 10, 190));
     root_->set_expected_occlusion(gfx::Rect(10, 10, 10, 190));
 
     layer_tree_host()->SetRootLayer(root_);
     LayerTreeTest::SetupTree();
   }
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(
     LayerTreeHostOcclusionTestOcclusionSurfaceClipping);
 
 class LayerTreeHostOcclusionTestOcclusionSurfaceClippingOpaque
     : public LayerTreeHostOcclusionTest {
  public:
   virtual void SetupTree() override {
     // If the child layer is opaque, then it adds to the occlusion seen by the
     // root_.
     SetLayerPropertiesForTesting(
-        root_.get(), NULL, identity_matrix_,
+        root_.get(), nullptr, identity_matrix_,
         gfx::PointF(0.f, 0.f), gfx::Size(200, 200), true);
     SetLayerPropertiesForTesting(
         child_.get(), root_.get(), identity_matrix_,
         gfx::PointF(10.f, 10.f), gfx::Size(500, 500), true);
     SetLayerPropertiesForTesting(
         grand_child_.get(), child_.get(), identity_matrix_,
         gfx::PointF(-10.f, -10.f), gfx::Size(20, 500), true);
 
     child_->SetMasksToBounds(true);
     child_->SetForceRenderSurface(true);
 
     child_->set_expected_occlusion(gfx::Rect(0, 0, 10, 190));
     root_->set_expected_occlusion(gfx::Rect(10, 10, 190, 190));
 
     layer_tree_host()->SetRootLayer(root_);
     LayerTreeTest::SetupTree();
   }
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(
     LayerTreeHostOcclusionTestOcclusionSurfaceClippingOpaque);
 
 class LayerTreeHostOcclusionTestOcclusionTwoChildren
     : public LayerTreeHostOcclusionTest {
  public:
   virtual void SetupTree() override {
     // Add a second child to the root layer and the regions should merge
     SetLayerPropertiesForTesting(
-        root_.get(), NULL, identity_matrix_,
+        root_.get(), nullptr, identity_matrix_,
         gfx::PointF(0.f, 0.f), gfx::Size(200, 200), true);
     SetLayerPropertiesForTesting(
         child_.get(), root_.get(), identity_matrix_,
         gfx::PointF(10.f, 10.f), gfx::Size(500, 500), false);
     SetLayerPropertiesForTesting(
         grand_child_.get(), child_.get(), identity_matrix_,
         gfx::PointF(-10.f, -10.f), gfx::Size(20, 500), true);
     SetLayerPropertiesForTesting(
         child2_.get(), root_.get(), identity_matrix_,
         gfx::PointF(20.f, 10.f), gfx::Size(10, 500), true);
@@ skipping 13 matching lines @@
 SINGLE_AND_MULTI_THREAD_TEST_F(
     LayerTreeHostOcclusionTestOcclusionTwoChildren);
 
 class LayerTreeHostOcclusionTestOcclusionMask
     : public LayerTreeHostOcclusionTest {
  public:
   virtual void SetupTree() override {
     // If the child layer has a mask on it, then it shouldn't contribute to
     // occlusion on stuff below it.
     SetLayerPropertiesForTesting(
-        root_.get(), NULL, identity_matrix_,
+        root_.get(), nullptr, identity_matrix_,
         gfx::PointF(0.f, 0.f), gfx::Size(200, 200), true);
     SetLayerPropertiesForTesting(
         child2_.get(), root_.get(), identity_matrix_,
         gfx::PointF(10.f, 10.f), gfx::Size(500, 500), true);
     SetLayerPropertiesForTesting(
         child_.get(), root_.get(), identity_matrix_,
         gfx::PointF(20.f, 20.f), gfx::Size(500, 500), true);
     SetLayerPropertiesForTesting(
         grand_child_.get(), child_.get(), identity_matrix_,
         gfx::PointF(-10.f, -10.f), gfx::Size(500, 500), true);
@@ skipping 13 matching lines @@
 SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostOcclusionTestOcclusionMask);
 
 class LayerTreeHostOcclusionTestOcclusionMaskBelowOcclusion
     : public LayerTreeHostOcclusionTest {
  public:
   virtual void SetupTree() override {
     // If the child layer with a mask is below child2, then child2 should
     // contribute to occlusion on everything, and child shouldn't contribute
     // to the root_.
     SetLayerPropertiesForTesting(
-        root_.get(), NULL, identity_matrix_,
+        root_.get(), nullptr, identity_matrix_,
         gfx::PointF(0.f, 0.f), gfx::Size(200, 200), true);
     SetLayerPropertiesForTesting(
         child_.get(), root_.get(), identity_matrix_,
         gfx::PointF(10.f, 10.f), gfx::Size(500, 500), true);
     SetLayerPropertiesForTesting(
         grand_child_.get(), child_.get(), identity_matrix_,
         gfx::PointF(-10.f, -10.f), gfx::Size(20, 500), true);
     SetLayerPropertiesForTesting(
         child2_.get(), root_.get(), identity_matrix_,
         gfx::PointF(20.f, 10.f), gfx::Size(10, 500), true);
@@ skipping 14 matching lines @@
 SINGLE_AND_MULTI_THREAD_TEST_F(
     LayerTreeHostOcclusionTestOcclusionMaskBelowOcclusion);
 
 class LayerTreeHostOcclusionTestOcclusionOpacity
     : public LayerTreeHostOcclusionTest {
  public:
   virtual void SetupTree() override {
     // If the child layer has a non-opaque opacity, then it shouldn't
     // contribute to occlusion on stuff below it
     SetLayerPropertiesForTesting(
-        root_.get(), NULL, identity_matrix_,
+        root_.get(), nullptr, identity_matrix_,
         gfx::PointF(0.f, 0.f), gfx::Size(200, 200), true);
     SetLayerPropertiesForTesting(
         child2_.get(), root_.get(), identity_matrix_,
         gfx::PointF(20.f, 10.f), gfx::Size(10, 500), true);
     SetLayerPropertiesForTesting(
         child_.get(), root_.get(), identity_matrix_,
         gfx::PointF(10.f, 10.f), gfx::Size(500, 500), true);
     SetLayerPropertiesForTesting(
         grand_child_.get(), child_.get(), identity_matrix_,
         gfx::PointF(-10.f, -10.f), gfx::Size(20, 500), true);
@@ skipping 13 matching lines @@
 SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostOcclusionTestOcclusionOpacity);
 
 class LayerTreeHostOcclusionTestOcclusionOpacityBelowOcclusion
     : public LayerTreeHostOcclusionTest {
  public:
   virtual void SetupTree() override {
     // If the child layer with non-opaque opacity is below child2, then
     // child2 should contribute to occlusion on everything, and child shouldn't
     // contribute to the root_.
     SetLayerPropertiesForTesting(
-        root_.get(), NULL, identity_matrix_,
+        root_.get(), nullptr, identity_matrix_,
         gfx::PointF(0.f, 0.f), gfx::Size(200, 200), true);
     SetLayerPropertiesForTesting(
         child_.get(), root_.get(), identity_matrix_,
         gfx::PointF(10.f, 10.f), gfx::Size(500, 500), true);
     SetLayerPropertiesForTesting(
         grand_child_.get(), child_.get(), identity_matrix_,
         gfx::PointF(-10.f, -10.f), gfx::Size(20, 500), true);
     SetLayerPropertiesForTesting(
         child2_.get(), root_.get(), identity_matrix_,
         gfx::PointF(20.f, 10.f), gfx::Size(10, 500), true);
@@ skipping 14 matching lines @@
 SINGLE_AND_MULTI_THREAD_TEST_F(
     LayerTreeHostOcclusionTestOcclusionOpacityBelowOcclusion);
 
 class LayerTreeHostOcclusionTestOcclusionBlending
     : public LayerTreeHostOcclusionTest {
  public:
   virtual void SetupTree() override {
     // If the child layer has a blend mode, then it shouldn't
     // contribute to occlusion on stuff below it
     SetLayerPropertiesForTesting(
-        root_.get(), NULL, identity_matrix_,
+        root_.get(), nullptr, identity_matrix_,
         gfx::PointF(0.f, 0.f), gfx::Size(200, 200), true);
     SetLayerPropertiesForTesting(
         child2_.get(), root_.get(), identity_matrix_,
         gfx::PointF(20.f, 10.f), gfx::Size(10, 500), true);
     SetLayerPropertiesForTesting(
         child_.get(), root_.get(), identity_matrix_,
         gfx::PointF(10.f, 10.f), gfx::Size(500, 500), true);
     SetLayerPropertiesForTesting(
         grand_child_.get(), child_.get(), identity_matrix_,
         gfx::PointF(-10.f, -10.f), gfx::Size(20, 500), true);
@@ skipping 13 matching lines @@
 SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostOcclusionTestOcclusionBlending);
 
 class LayerTreeHostOcclusionTestOcclusionBlendingBelowOcclusion
     : public LayerTreeHostOcclusionTest {
  public:
   virtual void SetupTree() override {
     // If the child layer with a blend mode is below child2, then
     // child2 should contribute to occlusion on everything, and child shouldn't
     // contribute to the root_.
     SetLayerPropertiesForTesting(
-        root_.get(), NULL, identity_matrix_,
+        root_.get(), nullptr, identity_matrix_,
         gfx::PointF(0.f, 0.f), gfx::Size(200, 200), true);
     SetLayerPropertiesForTesting(
         child_.get(), root_.get(), identity_matrix_,
         gfx::PointF(10.f, 10.f), gfx::Size(500, 500), true);
     SetLayerPropertiesForTesting(
         grand_child_.get(), child_.get(), identity_matrix_,
         gfx::PointF(-10.f, -10.f), gfx::Size(20, 500), true);
     SetLayerPropertiesForTesting(
         child2_.get(), root_.get(), identity_matrix_,
         gfx::PointF(20.f, 10.f), gfx::Size(10, 500), true);
@@ skipping 17 matching lines @@
     : public LayerTreeHostOcclusionTest {
  public:
   virtual void SetupTree() override {
     FilterOperations filters;
     filters.Append(FilterOperation::CreateOpacityFilter(0.5f));
 
     // If the child layer has a filter that changes alpha values, and is below
     // child2, then child2 should contribute to occlusion on everything,
     // and child shouldn't contribute to the root
     SetLayerPropertiesForTesting(
-        root_.get(), NULL, identity_matrix_,
+        root_.get(), nullptr, identity_matrix_,
         gfx::PointF(0.f, 0.f), gfx::Size(200, 200), true);
     SetLayerPropertiesForTesting(child_.get(),
                                  root_.get(),
                                  identity_matrix_,
                                  gfx::PointF(0.f, 0.f),
                                  gfx::Size(500, 500),
                                  true);
     SetLayerPropertiesForTesting(grand_child_.get(),
                                  child_.get(),
                                  identity_matrix_,
@@ skipping 36 matching lines @@
     child_transform.Rotate(90.0);
     child_transform.Translate(-250.0, -250.0);
 
     FilterOperations filters;
     filters.Append(FilterOperation::CreateBlurFilter(10.f));
 
     // If the child layer has a filter that moves pixels/changes alpha, and is
     // below child2, then child should not inherit occlusion from outside its
     // subtree, and should not contribute to the root
     SetLayerPropertiesForTesting(
-        root_.get(), NULL, identity_matrix_,
+        root_.get(), nullptr, identity_matrix_,
         gfx::PointF(0.f, 0.f), gfx::Size(200, 200), true);
     SetLayerPropertiesForTesting(
         child_.get(), root_.get(), child_transform,
         gfx::PointF(30.f, 30.f), gfx::Size(500, 500), true);
     SetLayerPropertiesForTesting(
         grand_child_.get(), child_.get(), identity_matrix_,
         gfx::PointF(10.f, 10.f), gfx::Size(500, 500), true);
     SetLayerPropertiesForTesting(
         child2_.get(), root_.get(), identity_matrix_,
         gfx::PointF(10.f, 70.f), gfx::Size(500, 500), true);
@@ skipping 16 matching lines @@
     : public LayerTreeHostOcclusionTest {
  public:
   static void CopyOutputCallback(scoped_ptr<CopyOutputResult> result) {}
 
   virtual void SetupTree() override {
     // If the child layer has copy request, and is below child2,
     // then child should not inherit occlusion from outside its subtree.
     // The child layer will still receive occlusion from inside, and
     // the root layer will recive occlusion from child.
     SetLayerPropertiesForTesting(
-        root_.get(), NULL, identity_matrix_,
+        root_.get(), nullptr, identity_matrix_,
         gfx::PointF(), gfx::Size(100, 100), true);
     SetLayerPropertiesForTesting(
         child_.get(), root_.get(), identity_matrix_,
         gfx::PointF(), gfx::Size(75, 75), true);
     SetLayerPropertiesForTesting(
         grand_child_.get(), child_.get(), identity_matrix_,
         gfx::PointF(), gfx::Size(75, 50), true);
     SetLayerPropertiesForTesting(
         child2_.get(), root_.get(), identity_matrix_,
         gfx::PointF(0.f, 25.f), gfx::Size(75, 75), true);
@@ skipping 14 matching lines @@
 
 class LayerTreeHostOcclusionTestOcclusionReplica
     : public LayerTreeHostOcclusionTest {
  public:
   virtual void SetupTree() override {
     // If the child layer has copy request, and is below child2,
     // then child should not inherit occlusion from outside its subtree.
     // The child layer will still receive occlusion from inside, and
     // the root layer will recive occlusion from child.
     SetLayerPropertiesForTesting(
-        root_.get(), NULL, identity_matrix_,
+        root_.get(), nullptr, identity_matrix_,
         gfx::PointF(), gfx::Size(100, 100), true);
     SetLayerPropertiesForTesting(
         child_.get(), root_.get(), identity_matrix_,
         gfx::PointF(), gfx::Size(75, 75), true);
     SetLayerPropertiesForTesting(
         grand_child_.get(), child_.get(), identity_matrix_,
         gfx::PointF(), gfx::Size(75, 50), true);
     SetLayerPropertiesForTesting(
         child2_.get(), root_.get(), identity_matrix_,
         gfx::PointF(0.f, 25.f), gfx::Size(75, 75), true);
@@ skipping 20 matching lines @@
     // while computing occlusion.
     std::vector<scoped_refptr<TestLayer> > layers;
     int num_surfaces = 200;
     int root_width = 400;
     int root_height = 400;
 
     for (int i = 0; i < num_surfaces; ++i) {
       layers.push_back(TestLayer::Create());
       if (i == 0) {
         SetLayerPropertiesForTesting(
-            layers.back().get(), NULL, identity_matrix_,
+            layers.back().get(), nullptr, identity_matrix_,
             gfx::PointF(0.f, 0.f),
             gfx::Size(root_width, root_height), true);
       } else {
         SetLayerPropertiesForTesting(
             layers.back().get(), layers[layers.size() - 2].get(),
             identity_matrix_,
             gfx::PointF(1.f, 1.f),
             gfx::Size(root_width-i, root_height-i), true);
         layers.back()->SetForceRenderSurface(true);
       }
@@ skipping 13 matching lines @@
 
     layer_tree_host()->SetRootLayer(layers[0]);
     LayerTreeTest::SetupTree();
   }
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostOcclusionTestManySurfaces);
 
 }  // namespace
 }  // namespace cc