Replace NULL with nullptr in all C++ files.

webrtc/pc/videocapturertracksource_unittest.cc

 /*
  *  Copyright 2012 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
@@ skipping 98 matching lines @@
  protected:
   VideoCapturerTrackSourceTest() { InitCapturer(false); }
   void InitCapturer(bool is_screencast) {
     capturer_cleanup_ = std::unique_ptr<TestVideoCapturer>(
         new TestVideoCapturer(is_screencast));
     capturer_ = capturer_cleanup_.get();
   }
 
   void InitScreencast() { InitCapturer(true); }
 
-  void CreateVideoCapturerSource() { CreateVideoCapturerSource(NULL); }
+  void CreateVideoCapturerSource() { CreateVideoCapturerSource(nullptr); }
 
   void CreateVideoCapturerSource(
       const webrtc::MediaConstraintsInterface* constraints) {
     // VideoSource take ownership of |capturer_|
     source_ = VideoCapturerTrackSource::Create(rtc::Thread::Current(),
                                                capturer_cleanup_.release(),
                                                constraints, false);
 
-    ASSERT_TRUE(source_.get() != NULL);
+    ASSERT_TRUE(source_.get() != nullptr);
 
     state_observer_.reset(new StateObserver(source_));
     source_->RegisterObserver(state_observer_.get());
     source_->AddOrUpdateSink(&renderer_, rtc::VideoSinkWants());
   }
 
   std::unique_ptr<TestVideoCapturer> capturer_cleanup_;
   TestVideoCapturer* capturer_;
   cricket::FakeVideoRenderer renderer_;
   std::unique_ptr<StateObserver> state_observer_;
@@ skipping 34 matching lines @@
 TEST_F(VideoCapturerTrackSourceTest, MandatoryConstraintCif5Fps) {
   FakeConstraints constraints;
   constraints.AddMandatory(MediaConstraintsInterface::kMaxWidth, 352);
   constraints.AddMandatory(MediaConstraintsInterface::kMaxHeight, 288);
   constraints.AddMandatory(MediaConstraintsInterface::kMaxFrameRate, 5);
 
   CreateVideoCapturerSource(&constraints);
   EXPECT_EQ_WAIT(MediaSourceInterface::kLive, state_observer_->state(),
                  kMaxWaitMs);
   const cricket::VideoFormat* format = capturer_->GetCaptureFormat();
-  ASSERT_TRUE(format != NULL);
+  ASSERT_TRUE(format != nullptr);
   EXPECT_EQ(352, format->width);
   EXPECT_EQ(288, format->height);
   EXPECT_EQ(5, format->framerate());
 }
 
 // Test that the capture output is 720P if the camera support it and the
 // optional constraint is set to 720P.
 TEST_F(VideoCapturerTrackSourceTest, MandatoryMinVgaOptional720P) {
   FakeConstraints constraints;
   constraints.AddMandatory(MediaConstraintsInterface::kMinWidth, 640);
   constraints.AddMandatory(MediaConstraintsInterface::kMinHeight, 480);
   constraints.AddOptional(MediaConstraintsInterface::kMinWidth, 1280);
   constraints.AddOptional(MediaConstraintsInterface::kMinAspectRatio,
                           1280.0 / 720);
 
   CreateVideoCapturerSource(&constraints);
   EXPECT_EQ_WAIT(MediaSourceInterface::kLive, state_observer_->state(),
                  kMaxWaitMs);
   const cricket::VideoFormat* format = capturer_->GetCaptureFormat();
-  ASSERT_TRUE(format != NULL);
+  ASSERT_TRUE(format != nullptr);
   EXPECT_EQ(1280, format->width);
   EXPECT_EQ(720, format->height);
   EXPECT_EQ(30, format->framerate());
 }
 
 // Test that the capture output have aspect ratio 4:3 if a mandatory constraint
 // require it even if an optional constraint request a higher resolution
 // that don't have this aspect ratio.
 TEST_F(VideoCapturerTrackSourceTest, MandatoryAspectRatio4To3) {
   FakeConstraints constraints;
   constraints.AddMandatory(MediaConstraintsInterface::kMinWidth, 640);
   constraints.AddMandatory(MediaConstraintsInterface::kMinHeight, 480);
   constraints.AddMandatory(MediaConstraintsInterface::kMaxAspectRatio,
                            640.0 / 480);
   constraints.AddOptional(MediaConstraintsInterface::kMinWidth, 1280);
 
   CreateVideoCapturerSource(&constraints);
   EXPECT_EQ_WAIT(MediaSourceInterface::kLive, state_observer_->state(),
                  kMaxWaitMs);
   const cricket::VideoFormat* format = capturer_->GetCaptureFormat();
-  ASSERT_TRUE(format != NULL);
+  ASSERT_TRUE(format != nullptr);
   EXPECT_EQ(640, format->width);
   EXPECT_EQ(480, format->height);
   EXPECT_EQ(30, format->framerate());
 }
 
 // Test that the source state transition to kEnded if the mandatory aspect ratio
 // is set higher than supported.
 TEST_F(VideoCapturerTrackSourceTest, MandatoryAspectRatioTooHigh) {
   FakeConstraints constraints;
   constraints.AddMandatory(MediaConstraintsInterface::kMinAspectRatio, 2);
   CreateVideoCapturerSource(&constraints);
   EXPECT_EQ_WAIT(MediaSourceInterface::kEnded, state_observer_->state(),
                  kMaxWaitMs);
 }
 
 // Test that the source ignores an optional aspect ratio that is higher than
 // supported.
 TEST_F(VideoCapturerTrackSourceTest, OptionalAspectRatioTooHigh) {
   FakeConstraints constraints;
   constraints.AddOptional(MediaConstraintsInterface::kMinAspectRatio, 2);
   CreateVideoCapturerSource(&constraints);
   EXPECT_EQ_WAIT(MediaSourceInterface::kLive, state_observer_->state(),
                  kMaxWaitMs);
   const cricket::VideoFormat* format = capturer_->GetCaptureFormat();
-  ASSERT_TRUE(format != NULL);
+  ASSERT_TRUE(format != nullptr);
   double aspect_ratio = static_cast<double>(format->width) / format->height;
   EXPECT_LT(aspect_ratio, 2);
 }
 
 // Test that the source starts video with the default resolution if the
 // camera doesn't support capability enumeration and there are no constraints.
 TEST_F(VideoCapturerTrackSourceTest, NoCameraCapability) {
   capturer_->TestWithoutCameraFormats();
 
   CreateVideoCapturerSource();
   EXPECT_EQ_WAIT(MediaSourceInterface::kLive, state_observer_->state(),
                  kMaxWaitMs);
   const cricket::VideoFormat* format = capturer_->GetCaptureFormat();
-  ASSERT_TRUE(format != NULL);
+  ASSERT_TRUE(format != nullptr);
   EXPECT_EQ(640, format->width);
   EXPECT_EQ(480, format->height);
   EXPECT_EQ(30, format->framerate());
 }
 
 // Test that the source can start the video and get the requested aspect ratio
 // if the camera doesn't support capability enumeration and the aspect ratio is
 // set.
 TEST_F(VideoCapturerTrackSourceTest, NoCameraCapability16To9Ratio) {
   capturer_->TestWithoutCameraFormats();
@@ skipping 116 matching lines @@
   constraints.AddMandatory(MediaConstraintsInterface::kMaxHeight, 288);
   constraints.AddOptional(MediaConstraintsInterface::kMaxFrameRate, 5);
 
   constraints.AddMandatory(MediaConstraintsInterface::kNoiseReduction, false);
   constraints.AddOptional(MediaConstraintsInterface::kNoiseReduction, true);
 
   CreateVideoCapturerSource(&constraints);
   EXPECT_EQ_WAIT(MediaSourceInterface::kLive, state_observer_->state(),
                  kMaxWaitMs);
   const cricket::VideoFormat* format = capturer_->GetCaptureFormat();
-  ASSERT_TRUE(format != NULL);
+  ASSERT_TRUE(format != nullptr);
   EXPECT_EQ(352, format->width);
   EXPECT_EQ(288, format->height);
   EXPECT_EQ(5, format->framerate());
 
   EXPECT_EQ(rtc::Optional<bool>(false), source_->needs_denoising());
 }
 
 // Tests that the source starts video with the default resolution for
 // screencast if no constraint is set.
 TEST_F(VideoCapturerTrackSourceTest, ScreencastResolutionNoConstraint) {
   InitScreencast();
   capturer_->TestWithoutCameraFormats();
 
   CreateVideoCapturerSource();
   ASSERT_TRUE(source_->is_screencast());
   EXPECT_EQ_WAIT(MediaSourceInterface::kLive, state_observer_->state(),
                  kMaxWaitMs);
   const cricket::VideoFormat* format = capturer_->GetCaptureFormat();
-  ASSERT_TRUE(format != NULL);
+  ASSERT_TRUE(format != nullptr);
   EXPECT_EQ(640, format->width);
   EXPECT_EQ(480, format->height);
   EXPECT_EQ(30, format->framerate());
 }
 
 // Tests that the source starts video with the max width and height set by
 // constraints for screencast.
 TEST_F(VideoCapturerTrackSourceTest, ScreencastResolutionWithConstraint) {
   FakeConstraints constraints;
   constraints.AddMandatory(MediaConstraintsInterface::kMaxWidth, 480);
   constraints.AddMandatory(MediaConstraintsInterface::kMaxHeight, 270);
 
   InitScreencast();
   capturer_->TestWithoutCameraFormats();
 
   CreateVideoCapturerSource(&constraints);
   ASSERT_TRUE(source_->is_screencast());
   EXPECT_EQ_WAIT(MediaSourceInterface::kLive, state_observer_->state(),
                  kMaxWaitMs);
   const cricket::VideoFormat* format = capturer_->GetCaptureFormat();
-  ASSERT_TRUE(format != NULL);
+  ASSERT_TRUE(format != nullptr);
   EXPECT_EQ(480, format->width);
   EXPECT_EQ(270, format->height);
   EXPECT_EQ(30, format->framerate());
 }
 
 TEST_F(VideoCapturerTrackSourceTest, MandatorySubOneFpsConstraints) {
   FakeConstraints constraints;
   constraints.AddMandatory(MediaConstraintsInterface::kMaxFrameRate, 0.5);
 
   CreateVideoCapturerSource(&constraints);
   EXPECT_EQ_WAIT(MediaSourceInterface::kEnded, state_observer_->state(),
                  kMaxWaitMs);
-  ASSERT_TRUE(capturer_->GetCaptureFormat() == NULL);
+  ASSERT_TRUE(capturer_->GetCaptureFormat() == nullptr);
 }
 
 TEST_F(VideoCapturerTrackSourceTest, OptionalSubOneFpsConstraints) {
   FakeConstraints constraints;
   constraints.AddOptional(MediaConstraintsInterface::kMaxFrameRate, 0.5);
 
   CreateVideoCapturerSource(&constraints);
   EXPECT_EQ_WAIT(MediaSourceInterface::kLive, state_observer_->state(),
                  kMaxWaitMs);
   const cricket::VideoFormat* format = capturer_->GetCaptureFormat();
-  ASSERT_TRUE(format != NULL);
+  ASSERT_TRUE(format != nullptr);
   EXPECT_EQ(1, format->framerate());
 }