replace NULL->nullptr in src/remoting.

remoting/host/video_scheduler.cc

 // Copyright (c) 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 "remoting/host/video_scheduler.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/callback.h"
@@ skipping 58 matching lines @@
   DCHECK(capturer_);
   DCHECK(mouse_cursor_monitor_);
   DCHECK(encoder_);
   DCHECK(cursor_stub_);
   DCHECK(video_stub_);
 }
 
 // Public methods --------------------------------------------------------------
 
 webrtc::SharedMemory* VideoScheduler::CreateSharedMemory(size_t size) {
-  return NULL;
+  return nullptr;
 }
 
 void VideoScheduler::OnCaptureCompleted(webrtc::DesktopFrame* frame) {
   DCHECK(capture_task_runner_->BelongsToCurrentThread());
 
   capture_pending_ = false;
 
   scoped_ptr<webrtc::DesktopFrame> owned_frame(frame);
 
   if (owned_frame) {
     scheduler_.RecordCaptureTime(
         base::TimeDelta::FromMilliseconds(owned_frame->capture_time_ms()));
   }
 
-  // Even when |frame| is NULL we still need to post it to the encode thread
+  // Even when |frame| is nullptr we still need to post it to the encode thread
   // to make sure frames are freed in the same order they are received and
   // that we don't start capturing frame n+2 before frame n is freed.
   encode_task_runner_->PostTask(
       FROM_HERE, base::Bind(&VideoScheduler::EncodeFrame, this,
                             base::Passed(&owned_frame), latest_event_timestamp_,
                             base::TimeTicks::Now()));
 
   // If a frame was skipped, try to capture it again.
   if (did_skip_frame_) {
     capture_task_runner_->PostTask(
@@ skipping 43 matching lines @@
   DCHECK(network_task_runner_->BelongsToCurrentThread());
 
   capture_task_runner_->PostTask(
       FROM_HERE, base::Bind(&VideoScheduler::StartOnCaptureThread, this));
 }
 
 void VideoScheduler::Stop() {
   DCHECK(network_task_runner_->BelongsToCurrentThread());
 
   // Clear stubs to prevent further updates reaching the client.
-  cursor_stub_ = NULL;
-  video_stub_ = NULL;
+  cursor_stub_ = nullptr;
+  video_stub_ = nullptr;
 
   keep_alive_timer_.reset();
 
   capture_task_runner_->PostTask(
       FROM_HERE, base::Bind(&VideoScheduler::StopOnCaptureThread, this));
 }
 
 void VideoScheduler::Pause(bool pause) {
   if (!capture_task_runner_->BelongsToCurrentThread()) {
     DCHECK(network_task_runner_->BelongsToCurrentThread());
@@ skipping 93 matching lines @@
 
   capture_timer_->Start(FROM_HERE,
                         scheduler_.NextCaptureDelay(),
                         this,
                         &VideoScheduler::CaptureNextFrame);
 }
 
 void VideoScheduler::CaptureNextFrame() {
   DCHECK(capture_task_runner_->BelongsToCurrentThread());
 
-  // If we are stopping (|capturer_| is NULL), or paused, then don't capture.
+  // If we are stopping (|capturer_| is nullptr), or paused, then don't capture.
   if (!capturer_ || is_paused_)
     return;
 
   // Make sure we have at most two outstanding recordings. We can simply return
   // if we can't make a capture now, the next capture will be started by the
   // end of an encode operation.
   if (pending_frames_ >= kMaxPendingFrames || capture_pending_) {
     did_skip_frame_ = true;
     return;
   }
@@ skipping 114 matching lines @@
   frame.reset();
 
   scheduler_.RecordEncodeTime(
       base::TimeDelta::FromMilliseconds(packet->encode_time_ms()));
   network_task_runner_->PostTask(
       FROM_HERE, base::Bind(&VideoScheduler::SendVideoPacket, this,
                             base::Passed(&packet)));
 }
 
 }  // namespace remoting