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

cc/trees/layer_tree_host_unittest_context.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 "base/basictypes.h"
 #include "cc/layers/content_layer.h"
 #include "cc/layers/delegated_frame_provider.h"
 #include "cc/layers/delegated_frame_resource_collection.h"
@@ skipping 36 matching lines @@
 using media::VideoFrame;
 
 namespace cc {
 namespace {
 
 // These tests deal with losing the 3d graphics context.
 class LayerTreeHostContextTest : public LayerTreeTest {
  public:
   LayerTreeHostContextTest()
       : LayerTreeTest(),
-        context3d_(NULL),
+        context3d_(nullptr),
         times_to_fail_create_(0),
         times_to_lose_during_commit_(0),
         times_to_lose_during_draw_(0),
         times_to_fail_recreate_(0),
         times_to_expect_create_failed_(0),
         times_create_failed_(0),
         committed_at_least_once_(false),
         context_should_support_io_surface_(false),
         fallback_context_works_(false),
         async_output_surface_creation_(false) {
     media::InitializeMediaLibraryForTesting();
   }
 
   void LoseContext() {
     // For sanity-checking tests, they should only call this when the
     // context is not lost.
     CHECK(context3d_);
     context3d_->loseContextCHROMIUM(GL_GUILTY_CONTEXT_RESET_ARB,
                                     GL_INNOCENT_CONTEXT_RESET_ARB);
-    context3d_ = NULL;
+    context3d_ = nullptr;
   }
 
   virtual scoped_ptr<TestWebGraphicsContext3D> CreateContext3d() {
     return TestWebGraphicsContext3D::Create();
   }
 
   virtual scoped_ptr<FakeOutputSurface> CreateFakeOutputSurface(bool fallback)
       override {
     if (times_to_fail_create_) {
       --times_to_fail_create_;
@@ skipping 675 matching lines @@
 
     layer_tree_host()->SetRootLayer(root_);
     LayerTreeHostContextTest::SetupTree();
   }
 
   virtual void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
   virtual void DidActivateTreeOnThread(LayerTreeHostImpl* host_impl) override {
     LayerTreeHostContextTest::DidActivateTreeOnThread(host_impl);
 
-    FakePictureLayerImpl* root_picture = NULL;
-    FakePictureLayerImpl* child_picture = NULL;
-    FakePictureLayerImpl* grandchild_picture = NULL;
-    FakeContentLayerImpl* root_content = NULL;
-    FakeContentLayerImpl* child_content = NULL;
-    FakeContentLayerImpl* grandchild_content = NULL;
+    FakePictureLayerImpl* root_picture = nullptr;
+    FakePictureLayerImpl* child_picture = nullptr;
+    FakePictureLayerImpl* grandchild_picture = nullptr;
+    FakeContentLayerImpl* root_content = nullptr;
+    FakeContentLayerImpl* child_content = nullptr;
+    FakeContentLayerImpl* grandchild_content = nullptr;
 
     if (layer_tree_host()->settings().impl_side_painting) {
       root_picture = static_cast<FakePictureLayerImpl*>(
           host_impl->active_tree()->root_layer());
       child_picture =
           static_cast<FakePictureLayerImpl*>(root_picture->children()[0]);
       grandchild_picture =
           static_cast<FakePictureLayerImpl*>(child_picture->children()[0]);
 
     } else {
@@ skipping 58 matching lines @@
  public:
   LayerTreeHostContextTestDontUseLostResources() : lost_context_(false) {
     context_should_support_io_surface_ = true;
 
     child_output_surface_ = FakeOutputSurface::Create3d();
     child_output_surface_->BindToClient(&output_surface_client_);
     shared_bitmap_manager_.reset(new TestSharedBitmapManager());
     child_resource_provider_ =
         ResourceProvider::Create(child_output_surface_.get(),
                                  shared_bitmap_manager_.get(),
-                                 NULL,
+                                 nullptr,
                                  0,
                                  false,
                                  1,
                                  false);
   }
 
   static void EmptyReleaseCallback(unsigned sync_point, bool lost) {}
 
   virtual void SetupTree() override {
     gpu::gles2::GLES2Interface* gl =
@@ skipping 49 matching lines @@
 
     scoped_refptr<Layer> layer;
     if (layer_tree_host()->settings().impl_side_painting)
       layer = PictureLayer::Create(&client_);
     else
       layer = ContentLayer::Create(&client_);
     layer->SetBounds(gfx::Size(10, 10));
     layer->SetIsDrawable(true);
     root->AddChild(layer);
 
-    scoped_refptr<TextureLayer> texture = TextureLayer::CreateForMailbox(NULL);
+    scoped_refptr<TextureLayer> texture =
+        TextureLayer::CreateForMailbox(nullptr);
     texture->SetBounds(gfx::Size(10, 10));
     texture->SetIsDrawable(true);
     texture->SetTextureMailbox(
         TextureMailbox(mailbox, GL_TEXTURE_2D, sync_point),
         SingleReleaseCallback::Create(
             base::Bind(&LayerTreeHostContextTestDontUseLostResources::
                             EmptyReleaseCallback)));
     root->AddChild(texture);
 
     scoped_refptr<Layer> mask;
@@ skipping 83 matching lines @@
 
   virtual void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
   virtual void CommitCompleteOnThread(LayerTreeHostImpl* host_impl) override {
     LayerTreeHostContextTest::CommitCompleteOnThread(host_impl);
 
     if (host_impl->active_tree()->source_frame_number() == 3) {
       // On the third commit we're recovering from context loss. Hardware
       // video frames should not be reused by the VideoFrameProvider, but
       // software frames can be.
-      hw_frame_provider_.set_frame(NULL);
-      scaled_hw_frame_provider_.set_frame(NULL);
+      hw_frame_provider_.set_frame(nullptr);
+      scaled_hw_frame_provider_.set_frame(nullptr);
     }
   }
 
   virtual DrawResult PrepareToDrawOnThread(
       LayerTreeHostImpl* host_impl,
       LayerTreeHostImpl::FrameData* frame,
       DrawResult draw_result) override {
     if (host_impl->active_tree()->source_frame_number() == 2) {
       // Lose the context during draw on the second commit. This will cause
       // a third commit to recover.
@@ skipping 670 matching lines @@
   virtual void AfterTest() override {}
 
   bool deferred_;
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(
     LayerTreeHostContextTestLoseAfterSendingBeginMainFrame);
 
 }  // namespace
 }  // namespace cc