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

cc/output/overlay_unittest.cc

 // Copyright 2014 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/base/scoped_ptr_vector.h"
 #include "cc/output/gl_renderer.h"
 #include "cc/output/output_surface.h"
 #include "cc/output/output_surface_client.h"
 #include "cc/output/overlay_candidate_validator.h"
 #include "cc/output/overlay_processor.h"
@@ skipping 58 matching lines @@
     OutputSurface* surface,
     ResourceProvider* resource_provider)
     : OverlayProcessor(surface, resource_provider) {
   EXPECT_EQ(surface, surface_);
   EXPECT_EQ(resource_provider, resource_provider_);
 }
 
 void SingleOverlayProcessor::Initialize() {
   OverlayCandidateValidator* candidates =
       surface_->overlay_candidate_validator();
-  ASSERT_TRUE(candidates != NULL);
+  ASSERT_TRUE(candidates != nullptr);
   strategies_.push_back(scoped_ptr<Strategy>(
       new OverlayStrategySingleOnTop(candidates, resource_provider_)));
 }
 
 class DefaultOverlayProcessor : public OverlayProcessor {
  public:
   DefaultOverlayProcessor(OutputSurface* surface,
                           ResourceProvider* resource_provider);
   size_t GetStrategyCount();
 };
@@ skipping 123 matching lines @@
       EXPECT_EQ(exp_iter->rect.ToString(), act_iter->rect.ToString());
       EXPECT_EQ(exp_iter->shared_quad_state->content_bounds.ToString(),
                 act_iter->shared_quad_state->content_bounds.ToString());
     }
   }
 }
 
 TEST(OverlayTest, NoOverlaysByDefault) {
   scoped_refptr<TestContextProvider> provider = TestContextProvider::Create();
   OverlayOutputSurface output_surface(provider);
-  EXPECT_EQ(NULL, output_surface.overlay_candidate_validator());
+  EXPECT_EQ(nullptr, output_surface.overlay_candidate_validator());
 
   output_surface.InitWithSingleOverlayValidator();
-  EXPECT_TRUE(output_surface.overlay_candidate_validator() != NULL);
+  EXPECT_TRUE(output_surface.overlay_candidate_validator() != nullptr);
 }
 
 TEST(OverlayTest, OverlaysProcessorHasStrategy) {
   scoped_refptr<TestContextProvider> provider = TestContextProvider::Create();
   OverlayOutputSurface output_surface(provider);
   FakeOutputSurfaceClient client;
   EXPECT_TRUE(output_surface.BindToClient(&client));
   output_surface.InitWithSingleOverlayValidator();
-  EXPECT_TRUE(output_surface.overlay_candidate_validator() != NULL);
+  EXPECT_TRUE(output_surface.overlay_candidate_validator() != nullptr);
 
   scoped_ptr<SharedBitmapManager> shared_bitmap_manager(
       new TestSharedBitmapManager());
-  scoped_ptr<ResourceProvider> resource_provider(ResourceProvider::Create(
-      &output_surface, shared_bitmap_manager.get(), NULL, 0, false, 1, false));
+  scoped_ptr<ResourceProvider> resource_provider(
+      ResourceProvider::Create(&output_surface,
+                               shared_bitmap_manager.get(),
+                               nullptr,
+                               0,
+                               false,
+                               1,
+                               false));
 
   scoped_ptr<DefaultOverlayProcessor> overlay_processor(
       new DefaultOverlayProcessor(&output_surface, resource_provider.get()));
   overlay_processor->Initialize();
   EXPECT_GE(1U, overlay_processor->GetStrategyCount());
 }
 
 class SingleOverlayOnTopTest : public testing::Test {
  protected:
   virtual void SetUp() {
     provider_ = TestContextProvider::Create();
     output_surface_.reset(new OverlayOutputSurface(provider_));
     EXPECT_TRUE(output_surface_->BindToClient(&client_));
     output_surface_->InitWithSingleOverlayValidator();
-    EXPECT_TRUE(output_surface_->overlay_candidate_validator() != NULL);
+    EXPECT_TRUE(output_surface_->overlay_candidate_validator() != nullptr);
 
     shared_bitmap_manager_.reset(new TestSharedBitmapManager());
     resource_provider_ = ResourceProvider::Create(output_surface_.get(),
                                                   shared_bitmap_manager_.get(),
-                                                  NULL,
+                                                  nullptr,
                                                   0,
                                                   false,
                                                   1,
                                                   false);
 
     overlay_processor_.reset(new SingleOverlayProcessor(
         output_surface_.get(), resource_provider_.get()));
     overlay_processor_->Initialize();
   }
 
@@ skipping 245 matching lines @@
 class OverlayInfoRendererGL : public GLRenderer {
  public:
   OverlayInfoRendererGL(RendererClient* client,
                         const LayerTreeSettings* settings,
                         OutputSurface* output_surface,
                         ResourceProvider* resource_provider)
       : GLRenderer(client,
                    settings,
                    output_surface,
                    resource_provider,
-                   NULL,
+                   nullptr,
                    0),
         expect_overlays_(false) {}
 
   MOCK_METHOD2(DoDrawQuad, void(DrawingFrame* frame, const DrawQuad* quad));
 
   virtual void FinishDrawingFrame(DrawingFrame* frame) override {
     GLRenderer::FinishDrawingFrame(frame);
 
     if (!expect_overlays_) {
       EXPECT_EQ(0U, frame->overlay_list.size());
@@ skipping 28 matching lines @@
                     const gfx::RectF& uv_rect));
 };
 
 class GLRendererWithOverlaysTest : public testing::Test {
  protected:
   GLRendererWithOverlaysTest() {
     provider_ = TestContextProvider::Create();
     output_surface_.reset(new OverlayOutputSurface(provider_));
     CHECK(output_surface_->BindToClient(&output_surface_client_));
     resource_provider_ = ResourceProvider::Create(
-        output_surface_.get(), NULL, NULL, 0, false, 1, false);
+        output_surface_.get(), nullptr, nullptr, 0, false, 1, false);
 
     provider_->support()->SetScheduleOverlayPlaneCallback(base::Bind(
         &MockOverlayScheduler::Schedule, base::Unretained(&scheduler_)));
   }
 
   void Init(bool use_validator) {
     if (use_validator)
       output_surface_->InitWithSingleOverlayValidator();
 
     renderer_ =
@@ skipping 195 matching lines @@
   renderer_->set_expect_overlays(false);
   renderer_->FinishDrawingFrame(&frame3);
   EXPECT_TRUE(resource_provider_->InUseByConsumer(resource1));
   SwapBuffers();
   EXPECT_FALSE(resource_provider_->InUseByConsumer(resource1));
   Mock::VerifyAndClearExpectations(&scheduler_);
 }
 
 }  // namespace
 }  // namespace cc