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

cc/resources/picture_layer_tiling_unittest.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/resources/picture_layer_tiling.h"
 
 #include <limits>
 #include <set>
 
 #include "cc/base/math_util.h"
@@ skipping 841 matching lines @@
 
   priority = tiling->TileAt(3, 4)->priority(ACTIVE_TREE);
   EXPECT_FLOAT_EQ(30.f, priority.distance_to_visible);
 }
 
 TEST(PictureLayerTilingTest, ExpandRectEqual) {
   gfx::Rect in(40, 50, 100, 200);
   gfx::Rect bounds(-1000, -1000, 10000, 10000);
   int64 target_area = 100 * 200;
   gfx::Rect out = PictureLayerTiling::ExpandRectEquallyToAreaBoundedBy(
-      in, target_area, bounds, NULL);
+      in, target_area, bounds, nullptr);
   EXPECT_EQ(in.ToString(), out.ToString());
 }
 
 TEST(PictureLayerTilingTest, ExpandRectSmaller) {
   gfx::Rect in(40, 50, 100, 200);
   gfx::Rect bounds(-1000, -1000, 10000, 10000);
   int64 target_area = 100 * 100;
   gfx::Rect out = PictureLayerTiling::ExpandRectEquallyToAreaBoundedBy(
-      in, target_area, bounds, NULL);
+      in, target_area, bounds, nullptr);
   EXPECT_EQ(out.bottom() - in.bottom(), in.y() - out.y());
   EXPECT_EQ(out.right() - in.right(), in.x() - out.x());
   EXPECT_EQ(out.width() - in.width(), out.height() - in.height());
 
   // |in| represents the visible rect, and |out| represents the eventually rect.
   // If the eventually rect doesn't contain the visible rect, we will start
   // losing tiles.
   EXPECT_TRUE(out.Contains(in));
   EXPECT_TRUE(bounds.Contains(out));
 }
 
 TEST(PictureLayerTilingTest, ExpandRectUnbounded) {
   gfx::Rect in(40, 50, 100, 200);
   gfx::Rect bounds(-1000, -1000, 10000, 10000);
   int64 target_area = 200 * 200;
   gfx::Rect out = PictureLayerTiling::ExpandRectEquallyToAreaBoundedBy(
-      in, target_area, bounds, NULL);
+      in, target_area, bounds, nullptr);
   EXPECT_EQ(out.bottom() - in.bottom(), in.y() - out.y());
   EXPECT_EQ(out.right() - in.right(), in.x() - out.x());
   EXPECT_EQ(out.width() - in.width(), out.height() - in.height());
   EXPECT_NEAR(200 * 200, out.width() * out.height(), 100);
   EXPECT_TRUE(bounds.Contains(out));
 }
 
 TEST(PictureLayerTilingTest, ExpandRectBoundedSmaller) {
   gfx::Rect in(40, 50, 100, 200);
   gfx::Rect bounds(50, 60, 40, 30);
   int64 target_area = 200 * 200;
   gfx::Rect out = PictureLayerTiling::ExpandRectEquallyToAreaBoundedBy(
-      in, target_area, bounds, NULL);
+      in, target_area, bounds, nullptr);
   EXPECT_EQ(bounds.ToString(), out.ToString());
 }
 
 TEST(PictureLayerTilingTest, ExpandRectBoundedEqual) {
   gfx::Rect in(40, 50, 100, 200);
   gfx::Rect bounds = in;
   int64 target_area = 200 * 200;
   gfx::Rect out = PictureLayerTiling::ExpandRectEquallyToAreaBoundedBy(
-      in, target_area, bounds, NULL);
+      in, target_area, bounds, nullptr);
   EXPECT_EQ(bounds.ToString(), out.ToString());
 }
 
 TEST(PictureLayerTilingTest, ExpandRectBoundedSmallerStretchVertical) {
   gfx::Rect in(40, 50, 100, 200);
   gfx::Rect bounds(45, 0, 90, 300);
   int64 target_area = 200 * 200;
   gfx::Rect out = PictureLayerTiling::ExpandRectEquallyToAreaBoundedBy(
-      in, target_area, bounds, NULL);
+      in, target_area, bounds, nullptr);
   EXPECT_EQ(bounds.ToString(), out.ToString());
 }
 
 TEST(PictureLayerTilingTest, ExpandRectBoundedEqualStretchVertical) {
   gfx::Rect in(40, 50, 100, 200);
   gfx::Rect bounds(40, 0, 100, 300);
   int64 target_area = 200 * 200;
   gfx::Rect out = PictureLayerTiling::ExpandRectEquallyToAreaBoundedBy(
-      in, target_area, bounds, NULL);
+      in, target_area, bounds, nullptr);
   EXPECT_EQ(bounds.ToString(), out.ToString());
 }
 
 TEST(PictureLayerTilingTest, ExpandRectBoundedSmallerStretchHorizontal) {
   gfx::Rect in(40, 50, 100, 200);
   gfx::Rect bounds(0, 55, 180, 190);
   int64 target_area = 200 * 200;
   gfx::Rect out = PictureLayerTiling::ExpandRectEquallyToAreaBoundedBy(
-      in, target_area, bounds, NULL);
+      in, target_area, bounds, nullptr);
   EXPECT_EQ(bounds.ToString(), out.ToString());
 }
 
 TEST(PictureLayerTilingTest, ExpandRectBoundedEqualStretchHorizontal) {
   gfx::Rect in(40, 50, 100, 200);
   gfx::Rect bounds(0, 50, 180, 200);
   int64 target_area = 200 * 200;
   gfx::Rect out = PictureLayerTiling::ExpandRectEquallyToAreaBoundedBy(
-      in, target_area, bounds, NULL);
+      in, target_area, bounds, nullptr);
   EXPECT_EQ(bounds.ToString(), out.ToString());
 }
 
 TEST(PictureLayerTilingTest, ExpandRectBoundedLeft) {
   gfx::Rect in(40, 50, 100, 200);
   gfx::Rect bounds(20, -1000, 10000, 10000);
   int64 target_area = 200 * 200;
   gfx::Rect out = PictureLayerTiling::ExpandRectEquallyToAreaBoundedBy(
-      in, target_area, bounds, NULL);
+      in, target_area, bounds, nullptr);
   EXPECT_EQ(out.bottom() - in.bottom(), in.y() - out.y());
   EXPECT_EQ(out.bottom() - in.bottom(), out.right() - in.right());
   EXPECT_LE(out.width() * out.height(), target_area);
   EXPECT_GT(out.width() * out.height(),
             target_area - out.width() - out.height() * 2);
   EXPECT_TRUE(bounds.Contains(out));
 }
 
 TEST(PictureLayerTilingTest, ExpandRectBoundedRight) {
   gfx::Rect in(40, 50, 100, 200);
   gfx::Rect bounds(-1000, -1000, 1000+120, 10000);
   int64 target_area = 200 * 200;
   gfx::Rect out = PictureLayerTiling::ExpandRectEquallyToAreaBoundedBy(
-      in, target_area, bounds, NULL);
+      in, target_area, bounds, nullptr);
   EXPECT_EQ(out.bottom() - in.bottom(), in.y() - out.y());
   EXPECT_EQ(out.bottom() - in.bottom(), in.x() - out.x());
   EXPECT_LE(out.width() * out.height(), target_area);
   EXPECT_GT(out.width() * out.height(),
             target_area - out.width() - out.height() * 2);
   EXPECT_TRUE(bounds.Contains(out));
 }
 
 TEST(PictureLayerTilingTest, ExpandRectBoundedTop) {
   gfx::Rect in(40, 50, 100, 200);
   gfx::Rect bounds(-1000, 30, 10000, 10000);
   int64 target_area = 200 * 200;
   gfx::Rect out = PictureLayerTiling::ExpandRectEquallyToAreaBoundedBy(
-      in, target_area, bounds, NULL);
+      in, target_area, bounds, nullptr);
   EXPECT_EQ(out.right() - in.right(), in.x() - out.x());
   EXPECT_EQ(out.right() - in.right(), out.bottom() - in.bottom());
   EXPECT_LE(out.width() * out.height(), target_area);
   EXPECT_GT(out.width() * out.height(),
             target_area - out.width() * 2 - out.height());
   EXPECT_TRUE(bounds.Contains(out));
 }
 
 TEST(PictureLayerTilingTest, ExpandRectBoundedBottom) {
   gfx::Rect in(40, 50, 100, 200);
   gfx::Rect bounds(-1000, -1000, 10000, 1000 + 220);
   int64 target_area = 200 * 200;
   gfx::Rect out = PictureLayerTiling::ExpandRectEquallyToAreaBoundedBy(
-      in, target_area, bounds, NULL);
+      in, target_area, bounds, nullptr);
   EXPECT_EQ(out.right() - in.right(), in.x() - out.x());
   EXPECT_EQ(out.right() - in.right(), in.y() - out.y());
   EXPECT_LE(out.width() * out.height(), target_area);
   EXPECT_GT(out.width() * out.height(),
             target_area - out.width() * 2 - out.height());
   EXPECT_TRUE(bounds.Contains(out));
 }
 
 TEST(PictureLayerTilingTest, ExpandRectSquishedHorizontally) {
   gfx::Rect in(40, 50, 100, 200);
   gfx::Rect bounds(0, -4000, 100+40+20, 100000);
   int64 target_area = 400 * 400;
   gfx::Rect out = PictureLayerTiling::ExpandRectEquallyToAreaBoundedBy(
-      in, target_area, bounds, NULL);
+      in, target_area, bounds, nullptr);
   EXPECT_EQ(20, out.right() - in.right());
   EXPECT_EQ(40, in.x() - out.x());
   EXPECT_EQ(out.bottom() - in.bottom(), in.y() - out.y());
   EXPECT_LE(out.width() * out.height(), target_area);
   EXPECT_GT(out.width() * out.height(),
             target_area - out.width() * 2);
   EXPECT_TRUE(bounds.Contains(out));
 }
 
 TEST(PictureLayerTilingTest, ExpandRectSquishedVertically) {
   gfx::Rect in(40, 50, 100, 200);
   gfx::Rect bounds(-4000, 0, 100000, 200+50+30);
   int64 target_area = 400 * 400;
   gfx::Rect out = PictureLayerTiling::ExpandRectEquallyToAreaBoundedBy(
-      in, target_area, bounds, NULL);
+      in, target_area, bounds, nullptr);
   EXPECT_EQ(30, out.bottom() - in.bottom());
   EXPECT_EQ(50, in.y() - out.y());
   EXPECT_EQ(out.right() - in.right(), in.x() - out.x());
   EXPECT_LE(out.width() * out.height(), target_area);
   EXPECT_GT(out.width() * out.height(),
             target_area - out.height() * 2);
   EXPECT_TRUE(bounds.Contains(out));
 }
 
 TEST(PictureLayerTilingTest, ExpandRectOutOfBoundsFarAway) {
   gfx::Rect in(400, 500, 100, 200);
   gfx::Rect bounds(0, 0, 10, 10);
   int64 target_area = 400 * 400;
   gfx::Rect out = PictureLayerTiling::ExpandRectEquallyToAreaBoundedBy(
-      in, target_area, bounds, NULL);
+      in, target_area, bounds, nullptr);
   EXPECT_TRUE(out.IsEmpty());
 }
 
 TEST(PictureLayerTilingTest, ExpandRectOutOfBoundsExpandedFullyCover) {
   gfx::Rect in(40, 50, 100, 100);
   gfx::Rect bounds(0, 0, 10, 10);
   int64 target_area = 400 * 400;
   gfx::Rect out = PictureLayerTiling::ExpandRectEquallyToAreaBoundedBy(
-      in, target_area, bounds, NULL);
+      in, target_area, bounds, nullptr);
   EXPECT_EQ(bounds.ToString(), out.ToString());
 }
 
 TEST(PictureLayerTilingTest, ExpandRectOutOfBoundsExpandedPartlyCover) {
   gfx::Rect in(600, 600, 100, 100);
   gfx::Rect bounds(0, 0, 500, 500);
   int64 target_area = 400 * 400;
   gfx::Rect out = PictureLayerTiling::ExpandRectEquallyToAreaBoundedBy(
-      in, target_area, bounds, NULL);
+      in, target_area, bounds, nullptr);
   EXPECT_EQ(bounds.right(), out.right());
   EXPECT_EQ(bounds.bottom(), out.bottom());
   EXPECT_LE(out.width() * out.height(), target_area);
   EXPECT_GT(out.width() * out.height(),
             target_area - out.width() - out.height());
   EXPECT_TRUE(bounds.Contains(out));
 }
 
 TEST(PictureLayerTilingTest, EmptyStartingRect) {
   // If a layer has a non-invertible transform, then the starting rect
   // for the layer would be empty.
   gfx::Rect in(40, 40, 0, 0);
   gfx::Rect bounds(0, 0, 10, 10);
   int64 target_area = 400 * 400;
   gfx::Rect out = PictureLayerTiling::ExpandRectEquallyToAreaBoundedBy(
-      in, target_area, bounds, NULL);
+      in, target_area, bounds, nullptr);
   EXPECT_TRUE(out.IsEmpty());
 }
 
 TEST(PictureLayerTilingTest, TilingRasterTileIteratorStaticViewport) {
   FakePictureLayerTilingClient client;
   scoped_ptr<TestablePictureLayerTiling> tiling;
 
   gfx::Rect viewport(50, 50, 100, 100);
   gfx::Size layer_bounds(800, 800);
 
@@ skipping 114 matching lines @@
       ACTIVE_TREE, viewport, 1.0f, 1.0, Occlusion());
   tiling->ComputeTilePriorityRects(
       ACTIVE_TREE, moved_viewport, 1.0f, 2.0, Occlusion());
   tiling->UpdateAllTilePrioritiesForTesting();
 
   gfx::Rect soon_rect = moved_viewport;
   soon_rect.Inset(-312.f, -312.f, -312.f, -312.f);
 
   // There are 3 bins in TilePriority.
   bool have_tiles[3] = {};
-  Tile* last_tile = NULL;
+  Tile* last_tile = nullptr;
   int eventually_bin_order_correct_count = 0;
   int eventually_bin_order_incorrect_count = 0;
   for (PictureLayerTiling::TilingRasterTileIterator it(tiling.get()); it;
        ++it) {
     if (!last_tile)
       last_tile = *it;
 
     Tile* new_tile = *it;
 
     TilePriority last_priority = last_tile->priority(ACTIVE_TREE);
@@ skipping 22 matching lines @@
   EXPECT_GT(eventually_bin_order_correct_count,
             eventually_bin_order_incorrect_count);
 
   EXPECT_TRUE(have_tiles[TilePriority::NOW]);
   EXPECT_TRUE(have_tiles[TilePriority::SOON]);
   EXPECT_TRUE(have_tiles[TilePriority::EVENTUALLY]);
 }
 
 static void TileExists(bool exists, Tile* tile,
                        const gfx::Rect& geometry_rect) {
-  EXPECT_EQ(exists, tile != NULL) << geometry_rect.ToString();
+  EXPECT_EQ(exists, tile != nullptr) << geometry_rect.ToString();
 }
 
 TEST(PictureLayerTilingTest, TilingEvictionTileIteratorStaticViewport) {
   FakeOutputSurfaceClient output_surface_client;
   scoped_ptr<FakeOutputSurface> output_surface = FakeOutputSurface::Create3d();
   CHECK(output_surface->BindToClient(&output_surface_client));
   TestSharedBitmapManager shared_bitmap_manager;
-  scoped_ptr<ResourceProvider> resource_provider = ResourceProvider::Create(
-      output_surface.get(), &shared_bitmap_manager, NULL, 0, false, 1, false);
+  scoped_ptr<ResourceProvider> resource_provider =
+      ResourceProvider::Create(output_surface.get(),
+                               &shared_bitmap_manager,
+                               nullptr,
+                               0,
+                               false,
+                               1,
+                               false);
 
   FakePictureLayerTilingClient client(resource_provider.get());
   scoped_ptr<TestablePictureLayerTiling> tiling;
 
   gfx::Rect viewport(50, 50, 100, 100);
   gfx::Size layer_bounds(2000, 2000);
 
   client.SetTileSize(gfx::Size(30, 30));
   client.set_tree(ACTIVE_TREE);
 
@@ skipping 135 matching lines @@
                                     Occlusion());
   VerifyTiles(1.f, gfx::Rect(layer_bounds), base::Bind(&TileExists, true));
 }
 
 static void TilesIntersectingRectExist(const gfx::Rect& rect,
                                        bool intersect_exists,
                                        Tile* tile,
                                        const gfx::Rect& geometry_rect) {
   bool intersects = rect.Intersects(geometry_rect);
   bool expected_exists = intersect_exists ? intersects : !intersects;
-  EXPECT_EQ(expected_exists, tile != NULL)
+  EXPECT_EQ(expected_exists, tile != nullptr)
       << "Rects intersecting " << rect.ToString() << " should exist. "
       << "Current tile rect is " << geometry_rect.ToString();
 }
 
 TEST_F(PictureLayerTilingIteratorTest,
        TilesExistLargeViewportAndLayerWithSmallVisibleArea) {
   gfx::Size layer_bounds(10000, 10000);
   Initialize(gfx::Size(100, 100), 1.f, layer_bounds);
   VerifyTilesExactlyCoverRect(1.f, gfx::Rect(layer_bounds));
   VerifyTiles(1.f, gfx::Rect(layer_bounds), base::Bind(&TileExists, false));
@@ skipping 657 matching lines @@
   scoped_ptr<TestablePictureLayerTiling> recycle_tiling;
   recycle_tiling = TestablePictureLayerTiling::Create(1.0f,  // contents_scale
                                                       gfx::Size(10000, 10000),
                                                       &recycle_client);
 
   // Create all tiles on the second tiling. All tiles should be shared.
   recycle_tiling->ComputeTilePriorityRects(
       PENDING_TREE, gfx::Rect(0, 0, 100, 100), 1.0f, 1.0f, Occlusion());
 
   // Set the second tiling as recycled.
-  active_client.set_twin_tiling(NULL);
+  active_client.set_twin_tiling(nullptr);
   active_client.set_recycled_twin_tiling(recycle_tiling.get());
-  recycle_client.set_twin_tiling(NULL);
+  recycle_client.set_twin_tiling(nullptr);
 
   // Verify that tiles exist and are shared.
   EXPECT_TRUE(active_tiling->TileAt(0, 0));
   EXPECT_TRUE(recycle_tiling->TileAt(0, 0));
   EXPECT_EQ(active_tiling->TileAt(0, 0), recycle_tiling->TileAt(0, 0));
 
   // Move the viewport far away from the (0, 0) tile.
   active_tiling->ComputeTilePriorityRects(
       ACTIVE_TREE, gfx::Rect(9000, 9000, 100, 100), 1.0f, 2.0, Occlusion());
   // Ensure the tile was deleted on both tilings.
@@ skipping 31 matching lines @@
   scoped_ptr<TestablePictureLayerTiling> recycle_tiling;
   recycle_tiling = TestablePictureLayerTiling::Create(1.0f,  // contents_scale
                                                       gfx::Size(100, 100),
                                                       &recycle_client);
 
   // Create all tiles on the recycle tiling. All tiles should be shared.
   recycle_tiling->ComputeTilePriorityRects(
       PENDING_TREE, gfx::Rect(0, 0, 100, 100), 1.0f, 1.0f, Occlusion());
 
   // Set the second tiling as recycled.
-  active_client.set_twin_tiling(NULL);
+  active_client.set_twin_tiling(nullptr);
   active_client.set_recycled_twin_tiling(recycle_tiling.get());
-  recycle_client.set_twin_tiling(NULL);
+  recycle_client.set_twin_tiling(nullptr);
 
   // Verify that tiles exist and are shared.
   EXPECT_TRUE(active_tiling->TileAt(0, 0));
   EXPECT_TRUE(recycle_tiling->TileAt(0, 0));
   EXPECT_EQ(active_tiling->TileAt(0, 0), recycle_tiling->TileAt(0, 0));
 
   // Reset the active tiling. The recycle tiles should be released too.
   active_tiling->Reset();
   EXPECT_FALSE(active_tiling->TileAt(0, 0));
   EXPECT_FALSE(recycle_tiling->TileAt(0, 0));
 }
 
 }  // namespace
 }  // namespace cc