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

cc/layers/tiled_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/tiled_layer.h"
 
 #include <limits>
 #include <vector>
 
 #include "base/run_loop.h"
@@ skipping 76 matching lines @@
                                       impl_task_runner);
   }
 
   bool output_surface_created_;
   base::RunLoop run_loop_;
 };
 
 class TiledLayerTest : public testing::Test {
  public:
   TiledLayerTest()
-      : proxy_(NULL),
+      : proxy_(nullptr),
         output_surface_(FakeOutputSurface::Create3d()),
         queue_(make_scoped_ptr(new ResourceUpdateQueue)),
         impl_thread_("ImplThread"),
         fake_layer_tree_host_client_(FakeLayerTreeHostClient::DIRECT_3D),
-        occlusion_(NULL) {
+        occlusion_(nullptr) {
     settings_.max_partial_texture_updates = std::numeric_limits<size_t>::max();
     settings_.layer_transforms_should_scale_layer_contents = true;
   }
 
   virtual void SetUp() {
     impl_thread_.Start();
     shared_bitmap_manager_.reset(new TestSharedBitmapManager());
     layer_tree_host_ = SynchronousOutputSurfaceLayerTreeHost::Create(
         &fake_layer_tree_host_client_,
         shared_bitmap_manager_.get(),
         settings_,
         impl_thread_.message_loop_proxy());
     fake_layer_tree_host_client_.SetLayerTreeHost(layer_tree_host_.get());
     proxy_ = layer_tree_host_->proxy();
     resource_manager_ = PrioritizedResourceManager::Create(proxy_);
     layer_tree_host_->SetLayerTreeHostClientReady();
     CHECK(layer_tree_host_->EnsureOutputSurfaceCreated());
     layer_tree_host_->SetRootLayer(Layer::Create());
 
     CHECK(output_surface_->BindToClient(&output_surface_client_));
 
     DebugScopedSetImplThreadAndMainThreadBlocked
         impl_thread_and_main_thread_blocked(proxy_);
     resource_provider_ = ResourceProvider::Create(output_surface_.get(),
                                                   shared_bitmap_manager_.get(),
-                                                  NULL,
+                                                  nullptr,
                                                   0,
                                                   false,
                                                   1,
                                                   false);
     host_impl_ = make_scoped_ptr(
         new FakeLayerTreeHostImpl(proxy_, shared_bitmap_manager_.get()));
   }
 
   virtual ~TiledLayerTest() {
     ResourceManagerClearAllMemory(resource_manager_.get(),
@@ skipping 15 matching lines @@
       resource_manager->ReduceMemory(resource_provider);
     }
     resource_manager->UnlinkAndClearEvictedBackings();
   }
 
   void UpdateTextures() {
     DebugScopedSetImplThreadAndMainThreadBlocked
     impl_thread_and_main_thread_blocked(proxy_);
     DCHECK(queue_);
     scoped_ptr<ResourceUpdateController> update_controller =
-        ResourceUpdateController::Create(NULL,
+        ResourceUpdateController::Create(nullptr,
                                          proxy_->ImplThreadTaskRunner(),
                                          queue_.Pass(),
                                          resource_provider_.get());
     update_controller->Finalize();
     queue_ = make_scoped_ptr(new ResourceUpdateQueue);
   }
 
   void LayerPushPropertiesTo(FakeTiledLayer* layer,
                              FakeTiledLayerImpl* layer_impl) {
     DebugScopedSetImplThreadAndMainThreadBlocked
@@ skipping 540 matching lines @@
     // Pretend the layer is animating.
     layer->draw_properties().target_space_transform_is_animating = true;
     layer->draw_properties().visible_content_rect = visible_rect;
     layer->SetLayerTreeHost(layer_tree_host_.get());
 
     // The layer should paint its entire contents on the first paint
     // if it is close to the viewport size and has the available memory.
     layer->SetTexturePriorities(priority_calculator_);
     resource_manager_->PrioritizeTextures();
     layer->SavePaintProperties();
-    layer->Update(queue_.get(), NULL);
+    layer->Update(queue_.get(), nullptr);
     UpdateTextures();
     LayerPushPropertiesTo(layer.get(), layer_impl.get());
 
     // We should have all the tiles for the small animated layer.
     // We should still have the visible tiles when we didn't
     // have enough memory for all the tiles.
     if (!run_out_of_memory[i]) {
       for (int i = 0; i < 5; ++i) {
         for (int j = 0; j < 5; ++j)
           EXPECT_TRUE(layer_impl->HasResourceIdForTileAt(i, j));
@@ skipping 167 matching lines @@
   layer->draw_properties().contents_scale_y = 1.25f;
 
   // On first update, the update_rect includes all tiles, even beyond the
   // boundaries of the layer.
   // However, it should still be in layer space, not content space.
   layer->InvalidateContentRect(content_bounds);
 
   layer->SetTexturePriorities(priority_calculator_);
   resource_manager_->PrioritizeTextures();
   layer->SavePaintProperties();
-  layer->Update(queue_.get(), NULL);
+  layer->Update(queue_.get(), nullptr);
 
   // Update rect is 200x300 (tile size of 100x100). Scaled this gives 400x240.
   EXPECT_FLOAT_RECT_EQ(gfx::RectF(0, 0, 400, 240), layer->update_rect());
   UpdateTextures();
 
   // After the tiles are updated once, another invalidate only needs to update
   // the bounds of the layer.
   layer->SetTexturePriorities(priority_calculator_);
   resource_manager_->PrioritizeTextures();
   layer->InvalidateContentRect(content_bounds);
   layer->SavePaintProperties();
-  layer->Update(queue_.get(), NULL);
+  layer->Update(queue_.get(), nullptr);
   EXPECT_FLOAT_RECT_EQ(gfx::RectF(layer_bounds), layer->update_rect());
   UpdateTextures();
 
   // Partial re-paint should also be represented by the update rect in layer
   // space, not content space.
   gfx::Rect partial_damage(30, 100, 10, 10);
   layer->InvalidateContentRect(partial_damage);
   layer->SetTexturePriorities(priority_calculator_);
   resource_manager_->PrioritizeTextures();
   layer->SavePaintProperties();
-  layer->Update(queue_.get(), NULL);
+  layer->Update(queue_.get(), nullptr);
   EXPECT_FLOAT_RECT_EQ(gfx::RectF(60, 80, 20, 8), layer->update_rect());
 }
 
 TEST_F(TiledLayerTest, VerifyInvalidationWhenContentsScaleChanges) {
   scoped_refptr<FakeTiledLayer> layer =
       make_scoped_refptr(new FakeTiledLayer(resource_manager_.get()));
   scoped_ptr<FakeTiledLayerImpl> layer_impl =
       make_scoped_ptr(new FakeTiledLayerImpl(host_impl_->active_tree(), 1));
   RenderSurfaceLayerList render_surface_layer_list;
 
   layer_tree_host_->root_layer()->AddChild(layer);
 
   // Create a layer with one tile.
   layer->SetBounds(gfx::Size(100, 100));
   CalcDrawProps(&render_surface_layer_list);
   layer->draw_properties().visible_content_rect = gfx::Rect(0, 0, 100, 100);
-  layer->Update(queue_.get(), NULL);
+  layer->Update(queue_.get(), nullptr);
   UpdateTextures();
   EXPECT_FLOAT_RECT_EQ(gfx::RectF(0, 0, 100, 100),
                        layer->last_needs_display_rect());
 
   // Push the tiles to the impl side and check that there is exactly one.
   layer->SetTexturePriorities(priority_calculator_);
   resource_manager_->PrioritizeTextures();
   layer->SavePaintProperties();
-  layer->Update(queue_.get(), NULL);
+  layer->Update(queue_.get(), nullptr);
   UpdateTextures();
   LayerPushPropertiesTo(layer.get(), layer_impl.get());
   EXPECT_TRUE(layer_impl->HasResourceIdForTileAt(0, 0));
   EXPECT_FALSE(layer_impl->HasResourceIdForTileAt(0, 1));
   EXPECT_FALSE(layer_impl->HasResourceIdForTileAt(1, 0));
   EXPECT_FALSE(layer_impl->HasResourceIdForTileAt(1, 1));
 
   layer->SetNeedsDisplayRect(gfx::Rect());
   EXPECT_FLOAT_RECT_EQ(gfx::RectF(), layer->last_needs_display_rect());
 
   // Change the contents scale.
   layer->UpdateContentsScale(2.f);
   layer->draw_properties().visible_content_rect = gfx::Rect(0, 0, 200, 200);
 
   // The impl side should get 2x2 tiles now.
   layer->SetTexturePriorities(priority_calculator_);
   resource_manager_->PrioritizeTextures();
   layer->SavePaintProperties();
-  layer->Update(queue_.get(), NULL);
+  layer->Update(queue_.get(), nullptr);
   UpdateTextures();
   LayerPushPropertiesTo(layer.get(), layer_impl.get());
   EXPECT_TRUE(layer_impl->HasResourceIdForTileAt(0, 0));
   EXPECT_TRUE(layer_impl->HasResourceIdForTileAt(0, 1));
   EXPECT_TRUE(layer_impl->HasResourceIdForTileAt(1, 0));
   EXPECT_TRUE(layer_impl->HasResourceIdForTileAt(1, 1));
 
   // Verify that changing the contents scale caused invalidation, and
   // that the layer-space rectangle requiring painting is not scaled.
   EXPECT_FLOAT_RECT_EQ(gfx::RectF(0, 0, 100, 100),
@@ skipping 49 matching lines @@
   layer_tree_host_->CommitComplete();
 
   // Remove the child layer.
   root_layer->RemoveAllChildren();
 
   layer_tree_host_->UpdateLayers(queue_.get());
   EXPECT_FALSE(root_layer->SkipsDraw());
 
   ResourceManagerClearAllMemory(layer_tree_host_->contents_texture_manager(),
                                 resource_provider_.get());
-  layer_tree_host_->SetRootLayer(NULL);
+  layer_tree_host_->SetRootLayer(nullptr);
 }
 
 TEST_F(TiledLayerTest, ResizeToSmaller) {
   scoped_refptr<FakeTiledLayer> layer =
       make_scoped_refptr(new FakeTiledLayer(resource_manager_.get()));
 
   layer_tree_host_->root_layer()->AddChild(layer);
 
   layer->SetBounds(gfx::Size(700, 700));
   layer->draw_properties().visible_content_rect = gfx::Rect(0, 0, 700, 700);
   layer->InvalidateContentRect(gfx::Rect(0, 0, 700, 700));
 
   layer->SetTexturePriorities(priority_calculator_);
   resource_manager_->PrioritizeTextures();
   layer->SavePaintProperties();
-  layer->Update(queue_.get(), NULL);
+  layer->Update(queue_.get(), nullptr);
 
   layer->SetBounds(gfx::Size(200, 200));
   layer->InvalidateContentRect(gfx::Rect(0, 0, 200, 200));
 }
 
 TEST_F(TiledLayerTest, HugeLayerUpdateCrash) {
   scoped_refptr<FakeTiledLayer> layer =
       make_scoped_refptr(new FakeTiledLayer(resource_manager_.get()));
 
   layer_tree_host_->root_layer()->AddChild(layer);
 
   int size = 1 << 30;
   layer->SetBounds(gfx::Size(size, size));
   layer->draw_properties().visible_content_rect = gfx::Rect(0, 0, 700, 700);
   layer->InvalidateContentRect(gfx::Rect(0, 0, size, size));
 
   // Ensure no crash for bounds where size * size would overflow an int.
   layer->SetTexturePriorities(priority_calculator_);
   resource_manager_->PrioritizeTextures();
   layer->SavePaintProperties();
-  layer->Update(queue_.get(), NULL);
+  layer->Update(queue_.get(), nullptr);
 }
 
 class TiledLayerPartialUpdateTest : public TiledLayerTest {
  public:
   TiledLayerPartialUpdateTest() { settings_.max_partial_texture_updates = 4; }
 };
 
 TEST_F(TiledLayerPartialUpdateTest, PartialUpdates) {
   // Create one 300 x 200 tiled layer with 3 x 2 tiles.
   gfx::Size content_bounds(300, 200);
@@ skipping 92 matching lines @@
     UpdateTextures();
     EXPECT_EQ(4, layer->fake_layer_updater()->update_count());
     EXPECT_FALSE(queue_->HasMoreUpdates());
     layer->fake_layer_updater()->ClearUpdateCount();
     LayerPushPropertiesTo(layer.get(), layer_impl.get());
   }
   layer_tree_host_->CommitComplete();
 
   ResourceManagerClearAllMemory(layer_tree_host_->contents_texture_manager(),
                                 resource_provider_.get());
-  layer_tree_host_->SetRootLayer(NULL);
+  layer_tree_host_->SetRootLayer(nullptr);
 }
 
 TEST_F(TiledLayerTest, TilesPaintedWithoutOcclusion) {
   scoped_refptr<FakeTiledLayer> layer =
       make_scoped_refptr(new FakeTiledLayer(resource_manager_.get()));
   RenderSurfaceLayerList render_surface_layer_list;
 
   layer_tree_host_->root_layer()->AddChild(layer);
 
   // The tile size is 100x100, so this invalidates and then paints two tiles.
   layer->SetBounds(gfx::Size(100, 200));
   CalcDrawProps(&render_surface_layer_list);
 
   layer->SetTexturePriorities(priority_calculator_);
   resource_manager_->PrioritizeTextures();
   layer->SavePaintProperties();
-  layer->Update(queue_.get(), NULL);
+  layer->Update(queue_.get(), nullptr);
   EXPECT_EQ(2, layer->fake_layer_updater()->update_count());
 }
 
 TEST_F(TiledLayerTest, TilesPaintedWithOcclusion) {
   scoped_refptr<FakeTiledLayer> layer =
       make_scoped_refptr(new FakeTiledLayer(resource_manager_.get()));
   RenderSurfaceLayerList render_surface_layer_list;
   TestOcclusionTracker occluded;
   occlusion_ = &occluded;
 
@@ skipping 403 matching lines @@
       for (unsigned j = 0; j < 2; ++j)
         EXPECT_FALSE(root_impl->HasResourceIdForTileAt(i, j));
       EXPECT_FALSE(child_impl->HasResourceIdForTileAt(i, 0));
       EXPECT_FALSE(child2_impl->HasResourceIdForTileAt(i, 0));
     }
   }
   layer_tree_host_->CommitComplete();
 
   ResourceManagerClearAllMemory(layer_tree_host_->contents_texture_manager(),
                                 resource_provider_.get());
-  layer_tree_host_->SetRootLayer(NULL);
+  layer_tree_host_->SetRootLayer(nullptr);
 }
 
 class TrackingLayerPainter : public LayerPainter {
  public:
   static scoped_ptr<TrackingLayerPainter> Create() {
     return make_scoped_ptr(new TrackingLayerPainter());
   }
 
   virtual void Paint(SkCanvas* canvas, const gfx::Rect& content_rect) override {
     painted_rect_ = content_rect;
@@ skipping 45 matching lines @@
   gfx::Rect content_rect(0, 0, 45, 47);
   EXPECT_EQ(content_rect.size(), layer->content_bounds());
   layer->draw_properties().visible_content_rect = content_rect;
   layer->draw_properties().drawable_content_rect = content_rect;
 
   layer->SetTexturePriorities(priority_calculator_);
   resource_manager_->PrioritizeTextures();
   layer->SavePaintProperties();
 
   // Update the whole tile.
-  layer->Update(queue_.get(), NULL);
+  layer->Update(queue_.get(), nullptr);
   layer->tracking_layer_painter()->ResetPaintedRect();
 
   EXPECT_RECT_EQ(gfx::Rect(), layer->tracking_layer_painter()->PaintedRect());
   UpdateTextures();
 
   // Invalidate the entire layer in content space. When painting, the rect given
   // to webkit should match the layer's bounds.
   layer->InvalidateContentRect(content_rect);
-  layer->Update(queue_.get(), NULL);
+  layer->Update(queue_.get(), nullptr);
 
   // Rounding leads to an extra pixel.
   gfx::Rect expanded_layer_rect(layer_rect);
   expanded_layer_rect.set_height(32);
   EXPECT_RECT_EQ(expanded_layer_rect,
                  layer->tracking_layer_painter()->PaintedRect());
 }
 
 TEST_F(TiledLayerTest,
        NonIntegerContentsScaleIsNotDistortedDuringInvalidation) {
   scoped_refptr<UpdateTrackingTiledLayer> layer =
       make_scoped_refptr(new UpdateTrackingTiledLayer(resource_manager_.get()));
 
   layer_tree_host_->root_layer()->AddChild(layer);
 
   gfx::Rect layer_rect(0, 0, 30, 31);
   layer->SetPosition(layer_rect.origin());
   layer->SetBounds(layer_rect.size());
   layer->UpdateContentsScale(1.3f);
 
   gfx::Rect content_rect(layer->content_bounds());
   layer->draw_properties().visible_content_rect = content_rect;
   layer->draw_properties().drawable_content_rect = content_rect;
 
   layer->SetTexturePriorities(priority_calculator_);
   resource_manager_->PrioritizeTextures();
   layer->SavePaintProperties();
 
   // Update the whole tile.
-  layer->Update(queue_.get(), NULL);
+  layer->Update(queue_.get(), nullptr);
   layer->tracking_layer_painter()->ResetPaintedRect();
 
   EXPECT_RECT_EQ(gfx::Rect(), layer->tracking_layer_painter()->PaintedRect());
   UpdateTextures();
 
   // Invalidate the entire layer in layer space. When painting, the rect given
   // to webkit should match the layer's bounds.
   layer->SetNeedsDisplayRect(layer_rect);
-  layer->Update(queue_.get(), NULL);
+  layer->Update(queue_.get(), nullptr);
 
   // Rounding leads to an extra pixel.
   gfx::Rect expanded_layer_rect(layer_rect);
   expanded_layer_rect.set_height(32);
   EXPECT_RECT_EQ(expanded_layer_rect,
                  layer->tracking_layer_painter()->PaintedRect());
 }
 
 }  // namespace
 }  // namespace cc