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

cc/trees/layer_tree_host_impl_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_impl.h"
 
 #include <cmath>
 
 #include "base/bind.h"
 #include "base/command_line.h"
@@ skipping 3408 matching lines @@
   gfx::Size new_size(42, 24);
   host_impl_->CreatePendingTree();
   CreateScrollAndContentsLayers(host_impl_->pending_tree(), new_size);
   host_impl_->ActivateSyncTree();
   EXPECT_EQ(new_size, scroll_delegate.scrollable_size());
 
   // Un-setting the delegate should propagate the delegate's current offset to
   // the root scrollable layer.
   current_offset = gfx::ScrollOffset(13.f, 12.f);
   scroll_delegate.set_getter_return_value(current_offset);
-  host_impl_->SetRootLayerScrollOffsetDelegate(NULL);
+  host_impl_->SetRootLayerScrollOffsetDelegate(nullptr);
 
   EXPECT_EQ(current_offset.ToString(),
             scroll_layer->TotalScrollOffset().ToString());
 }
 
 void CheckLayerScrollDelta(LayerImpl* layer, gfx::Vector2dF scroll_delta) {
   const gfx::Transform target_space_transform =
       layer->draw_properties().target_space_transform;
   EXPECT_TRUE(target_space_transform.IsScaleOrTranslation());
   gfx::Point translated_point;
@@ skipping 18 matching lines @@
 
   // Set external scroll delta on delegate and notify LayerTreeHost.
   gfx::ScrollOffset scroll_offset(10.f, 10.f);
   scroll_delegate.set_getter_return_value(scroll_offset);
   host_impl_->OnRootLayerDelegatedScrollOffsetChanged();
 
   // Check scroll delta reflected in layer.
   DrawFrame();
   CheckLayerScrollDelta(scroll_layer, ScrollOffsetToVector2dF(scroll_offset));
 
-  host_impl_->SetRootLayerScrollOffsetDelegate(NULL);
+  host_impl_->SetRootLayerScrollOffsetDelegate(nullptr);
 }
 
 TEST_F(LayerTreeHostImplTest, OverscrollRoot) {
   SetupScrollAndContentsLayers(gfx::Size(100, 100));
   host_impl_->SetViewportSize(gfx::Size(50, 50));
   host_impl_->active_tree()->SetPageScaleFactorAndLimits(1.f, 0.5f, 4.f);
   DrawFrame();
   EXPECT_EQ(gfx::Vector2dF(), host_impl_->accumulated_root_overscroll());
 
   // In-bounds scrolling does not affect overscroll.
@@ skipping 557 matching lines @@
   EXPECT_EQ(DRAW_SUCCESS, host_impl_->PrepareToDraw(&frame));
   host_impl_->DrawLayers(&frame, gfx::FrameTime::Now());
   EXPECT_TRUE(layer1->quads_appended());
   host_impl_->DidDrawAllLayers(frame);
 }
 
 class LayerTreeHostImplViewportCoveredTest : public LayerTreeHostImplTest {
  protected:
   LayerTreeHostImplViewportCoveredTest() :
       gutter_quad_material_(DrawQuad::SOLID_COLOR),
-      child_(NULL),
+      child_(nullptr),
       did_activate_pending_tree_(false) {}
 
   scoped_ptr<OutputSurface> CreateFakeOutputSurface(bool always_draw) {
     if (always_draw) {
       return FakeOutputSurface::CreateAlwaysDrawAndSwap3d();
     }
     return FakeOutputSurface::Create3d();
   }
 
   void SetupActiveTreeLayers() {
@@ skipping 1779 matching lines @@
                                          resourceless_software_draw);
 
   EXPECT_EQ(0, software_device->frames_began_);
   EXPECT_EQ(0, software_device->frames_ended_);
 
   DrawFrame();
 
   EXPECT_EQ(1, software_device->frames_began_);
   EXPECT_EQ(1, software_device->frames_ended_);
 
-  // Call other API methods that are likely to hit NULL pointer in this mode.
+  // Call other API methods that are likely to hit nullptr pointer in this mode.
   EXPECT_TRUE(host_impl_->AsValue().get());
   EXPECT_TRUE(host_impl_->ActivationStateAsValue().get());
 }
 
 TEST_F(LayerTreeHostImplTest,
        ForcedDrawToSoftwareDeviceSkipsUnsupportedLayers) {
   set_reduce_memory_result(false);
   bool delegated_rendering = false;
   FakeOutputSurface* output_surface =
       FakeOutputSurface::CreateDeferredGL(
@@ skipping 140 matching lines @@
   int everything_cutoff_value = ManagedMemoryPolicy::PriorityCutoffToValue(
       gpu::MemoryAllocation::CUTOFF_ALLOW_EVERYTHING);
   int allow_nice_to_have_cutoff_value =
       ManagedMemoryPolicy::PriorityCutoffToValue(
           gpu::MemoryAllocation::CUTOFF_ALLOW_NICE_TO_HAVE);
   int nothing_cutoff_value = ManagedMemoryPolicy::PriorityCutoffToValue(
       gpu::MemoryAllocation::CUTOFF_ALLOW_NOTHING);
 
   // GPU rasterization should be disabled by default on the tree(s)
   EXPECT_FALSE(host_impl_->active_tree()->use_gpu_rasterization());
-  EXPECT_TRUE(host_impl_->pending_tree() == NULL);
+  EXPECT_TRUE(host_impl_->pending_tree() == nullptr);
 
   host_impl_->SetVisible(true);
   host_impl_->SetMemoryPolicy(policy1);
   EXPECT_EQ(policy1.bytes_limit_when_visible, current_limit_bytes_);
   EXPECT_EQ(everything_cutoff_value, current_priority_cutoff_value_);
 
   host_impl_->SetVisible(false);
   EXPECT_EQ(0u, current_limit_bytes_);
   EXPECT_EQ(nothing_cutoff_value, current_priority_cutoff_value_);
 
   host_impl_->SetVisible(true);
   EXPECT_EQ(policy1.bytes_limit_when_visible, current_limit_bytes_);
   EXPECT_EQ(everything_cutoff_value, current_priority_cutoff_value_);
 
   // Now enable GPU rasterization and test if we get nice to have cutoff,
   // when visible.
   LayerTreeSettings settings;
   settings.gpu_rasterization_enabled = true;
   host_impl_ = LayerTreeHostImpl::Create(
-      settings, this, &proxy_, &stats_instrumentation_, NULL, 0);
+      settings, this, &proxy_, &stats_instrumentation_, nullptr, 0);
   host_impl_->SetUseGpuRasterization(true);
   host_impl_->SetVisible(true);
   host_impl_->SetMemoryPolicy(policy1);
   EXPECT_EQ(policy1.bytes_limit_when_visible, current_limit_bytes_);
   EXPECT_EQ(allow_nice_to_have_cutoff_value, current_priority_cutoff_value_);
 
   host_impl_->SetVisible(false);
   EXPECT_EQ(0u, current_limit_bytes_);
   EXPECT_EQ(nothing_cutoff_value, current_priority_cutoff_value_);
 }
@@ skipping 518 matching lines @@
   LayerTreeHostImpl::FrameData frame;
   EXPECT_EQ(DRAW_SUCCESS, host_impl_->PrepareToDraw(&frame));
   host_impl_->DrawLayers(&frame, gfx::FrameTime::Now());
   host_impl_->DidDrawAllLayers(frame);
   EXPECT_TRUE(host_impl_->SwapBuffers(frame));
 
   const std::vector<ui::LatencyInfo>& metadata_latency_after =
       fake_output_surface->last_sent_frame().metadata.latency_info;
   EXPECT_EQ(1u, metadata_latency_after.size());
   EXPECT_TRUE(metadata_latency_after[0].FindLatency(
-      ui::INPUT_EVENT_LATENCY_BEGIN_RWH_COMPONENT, 0, NULL));
+      ui::INPUT_EVENT_LATENCY_BEGIN_RWH_COMPONENT, 0, nullptr));
 }
 
 TEST_F(LayerTreeHostImplTest, SelectionBoundsPassedToCompositorFrameMetadata) {
   int root_layer_id = 1;
   scoped_ptr<SolidColorLayerImpl> root =
       SolidColorLayerImpl::Create(host_impl_->active_tree(), root_layer_id);
   root->SetPosition(gfx::PointF());
   root->SetBounds(gfx::Size(10, 10));
   root->SetContentBounds(gfx::Size(10, 10));
   root->SetDrawsContent(true);
@@ skipping 76 matching lines @@
   int* forward_to_main_count_;
 };
 
 TEST_F(LayerTreeHostImplTest, SimpleSwapPromiseMonitor) {
   int set_needs_commit_count = 0;
   int set_needs_redraw_count = 0;
   int forward_to_main_count = 0;
 
   {
     scoped_ptr<SimpleSwapPromiseMonitor> swap_promise_monitor(
-        new SimpleSwapPromiseMonitor(NULL,
+        new SimpleSwapPromiseMonitor(nullptr,
                                      host_impl_.get(),
                                      &set_needs_commit_count,
                                      &set_needs_redraw_count,
                                      &forward_to_main_count));
     host_impl_->SetNeedsRedraw();
     EXPECT_EQ(0, set_needs_commit_count);
     EXPECT_EQ(1, set_needs_redraw_count);
     EXPECT_EQ(0, forward_to_main_count);
   }
 
   // Now the monitor is destroyed, SetNeedsRedraw() is no longer being
   // monitored.
   host_impl_->SetNeedsRedraw();
   EXPECT_EQ(0, set_needs_commit_count);
   EXPECT_EQ(1, set_needs_redraw_count);
   EXPECT_EQ(0, forward_to_main_count);
 
   {
     scoped_ptr<SimpleSwapPromiseMonitor> swap_promise_monitor(
-        new SimpleSwapPromiseMonitor(NULL,
+        new SimpleSwapPromiseMonitor(nullptr,
                                      host_impl_.get(),
                                      &set_needs_commit_count,
                                      &set_needs_redraw_count,
                                      &forward_to_main_count));
     host_impl_->SetNeedsRedrawRect(gfx::Rect(10, 10));
     EXPECT_EQ(0, set_needs_commit_count);
     EXPECT_EQ(2, set_needs_redraw_count);
     EXPECT_EQ(0, forward_to_main_count);
   }
 
   {
     scoped_ptr<SimpleSwapPromiseMonitor> swap_promise_monitor(
-        new SimpleSwapPromiseMonitor(NULL,
+        new SimpleSwapPromiseMonitor(nullptr,
                                      host_impl_.get(),
                                      &set_needs_commit_count,
                                      &set_needs_redraw_count,
                                      &forward_to_main_count));
     // Empty damage rect won't signal the monitor.
     host_impl_->SetNeedsRedrawRect(gfx::Rect());
     EXPECT_EQ(0, set_needs_commit_count);
     EXPECT_EQ(2, set_needs_redraw_count);
     EXPECT_EQ(0, forward_to_main_count);
   }
 
   {
     set_needs_commit_count = 0;
     set_needs_redraw_count = 0;
     forward_to_main_count = 0;
     scoped_ptr<SimpleSwapPromiseMonitor> swap_promise_monitor(
-        new SimpleSwapPromiseMonitor(NULL,
+        new SimpleSwapPromiseMonitor(nullptr,
                                      host_impl_.get(),
                                      &set_needs_commit_count,
                                      &set_needs_redraw_count,
                                      &forward_to_main_count));
     LayerImpl* scroll_layer = SetupScrollAndContentsLayers(gfx::Size(100, 100));
 
     // Scrolling normally should not trigger any forwarding.
     EXPECT_EQ(InputHandler::ScrollStarted,
               host_impl_->ScrollBegin(gfx::Point(), InputHandler::Gesture));
     EXPECT_TRUE(host_impl_->ScrollBy(gfx::Point(), gfx::Vector2d(0, 10)));
@@ skipping 420 matching lines @@
 
   y = scrolling_layer->TotalScrollOffset().y();
   EXPECT_TRUE(y > 50 && y < 100);
   EXPECT_EQ(scrolling_layer, host_impl_->CurrentlyScrollingLayer());
 
   host_impl_->Animate(start_time + base::TimeDelta::FromMilliseconds(250));
   host_impl_->UpdateAnimationState(true);
 
   EXPECT_VECTOR_EQ(gfx::ScrollOffset(0, 100),
                    scrolling_layer->TotalScrollOffset());
-  EXPECT_EQ(NULL, host_impl_->CurrentlyScrollingLayer());
+  EXPECT_EQ(nullptr, host_impl_->CurrentlyScrollingLayer());
 }
 
 TEST_F(LayerTreeHostImplTest, GetPictureLayerImplPairs) {
   host_impl_->CreatePendingTree();
   host_impl_->ActivateSyncTree();
   host_impl_->CreatePendingTree();
 
   LayerTreeImpl* active_tree = host_impl_->active_tree();
   LayerTreeImpl* pending_tree = host_impl_->pending_tree();
   EXPECT_NE(active_tree, pending_tree);
 
   scoped_ptr<FakePictureLayerImpl> active_layer =
       FakePictureLayerImpl::Create(active_tree, 10);
   scoped_ptr<FakePictureLayerImpl> pending_layer =
       FakePictureLayerImpl::Create(pending_tree, 10);
 
   std::vector<PictureLayerImpl::Pair> layer_pairs;
   host_impl_->GetPictureLayerImplPairs(&layer_pairs);
 
   EXPECT_EQ(2u, layer_pairs.size());
   if (layer_pairs[0].active) {
     EXPECT_EQ(active_layer.get(), layer_pairs[0].active);
-    EXPECT_EQ(NULL, layer_pairs[0].pending);
+    EXPECT_EQ(nullptr, layer_pairs[0].pending);
   } else {
     EXPECT_EQ(pending_layer.get(), layer_pairs[0].pending);
-    EXPECT_EQ(NULL, layer_pairs[0].active);
+    EXPECT_EQ(nullptr, layer_pairs[0].active);
   }
 
   if (layer_pairs[1].active) {
     EXPECT_EQ(active_layer.get(), layer_pairs[1].active);
-    EXPECT_EQ(NULL, layer_pairs[1].pending);
+    EXPECT_EQ(nullptr, layer_pairs[1].pending);
   } else {
     EXPECT_EQ(pending_layer.get(), layer_pairs[1].pending);
-    EXPECT_EQ(NULL, layer_pairs[1].active);
+    EXPECT_EQ(nullptr, layer_pairs[1].active);
   }
 
   active_layer->set_twin_layer(pending_layer.get());
   pending_layer->set_twin_layer(active_layer.get());
 
   layer_pairs.clear();
   host_impl_->GetPictureLayerImplPairs(&layer_pairs);
   EXPECT_EQ(1u, layer_pairs.size());
 
   EXPECT_EQ(active_layer.get(), layer_pairs[0].active);
@@ skipping 68 matching lines @@
   // surface.
   EXPECT_EQ(0, num_lost_surfaces_);
   host_impl_->DidLoseOutputSurface();
   EXPECT_EQ(1, num_lost_surfaces_);
   host_impl_->DidLoseOutputSurface();
   EXPECT_LE(1, num_lost_surfaces_);
 }
 
 }  // namespace
 }  // namespace cc