Replace scoped_ptr with unique_ptr in webrtc/media/

webrtc/media/base/videocapturer.cc

 /*
  *  Copyright (c) 2010 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 150 matching lines @@
     if (capture_state() == CS_PAUSED) {
       return true;
     }
     bool is_running = capture_state() == CS_STARTING ||
         capture_state() == CS_RUNNING;
     if (!is_running) {
       LOG(LS_ERROR) << "Cannot pause a stopped camera.";
       return false;
     }
     LOG(LS_INFO) << "Pausing a camera.";
-    rtc::scoped_ptr<VideoFormat> capture_format_when_paused(
+    std::unique_ptr<VideoFormat> capture_format_when_paused(
         capture_format_ ? new VideoFormat(*capture_format_) : NULL);
     Stop();
     SetCaptureState(CS_PAUSED);
     // If you override this function be sure to restore the capture format
     // after calling Stop().
     SetCaptureFormat(capture_format_when_paused.get());
   } else {  // Unpause.
     if (capture_state() != CS_PAUSED) {
       LOG(LS_WARNING) << "Cannot unpause a camera that hasn't been paused.";
       return false;
@@ skipping 162 matching lines @@
     } else {
       --black_frame_count_down_;
     }
   }
 
   if (!broadcaster_.frame_wanted()) {
     return;
   }
 
   // Use a temporary buffer to scale
-  rtc::scoped_ptr<uint8_t[]> scale_buffer;
+  std::unique_ptr<uint8_t[]> scale_buffer;
 
   if (IsScreencast()) {
     int scaled_width, scaled_height;
     int desired_screencast_fps = capture_format_.get() ?
       VideoFormat::IntervalToFps(capture_format_->interval) :
       kDefaultScreencastFps;
     ComputeScale(captured_frame->width, captured_frame->height,
                  desired_screencast_fps, &scaled_width, &scaled_height);
 
     if (FOURCC_ARGB == captured_frame->fourcc &&
@@ skipping 28 matching lines @@
     }
   }
 
   const int kYuy2Bpp = 2;
   const int kArgbBpp = 4;
   // TODO(fbarchard): Make a helper function to adjust pixels to square.
   // TODO(fbarchard): Hook up experiment to scaling.
   // TODO(fbarchard): Avoid scale and convert if muted.
   // Temporary buffer is scoped here so it will persist until i420_frame.Init()
   // makes a copy of the frame, converting to I420.
-  rtc::scoped_ptr<uint8_t[]> temp_buffer;
+  std::unique_ptr<uint8_t[]> temp_buffer;
   // YUY2 can be scaled vertically using an ARGB scaler.  Aspect ratio is only
   // a problem on OSX.  OSX always converts webcams to YUY2 or UYVY.
   bool can_scale =
       FOURCC_YUY2 == CanonicalFourCC(captured_frame->fourcc) ||
       FOURCC_UYVY == CanonicalFourCC(captured_frame->fourcc);
 
   // If pixels are not square, optionally use vertical scaling to make them
   // square.  Square pixels simplify the rest of the pipeline, including
   // effects and rendering.
   if (can_scale && square_pixel_aspect_ratio_ &&
@@ skipping 91 matching lines @@
     }
     adapted_width = adapted_format.width;
     adapted_height = adapted_format.height;
   }
 
   if (!frame_factory_) {
     LOG(LS_ERROR) << "No video frame factory.";
     return;
   }
 
-  rtc::scoped_ptr<VideoFrame> adapted_frame(
+  std::unique_ptr<VideoFrame> adapted_frame(
       frame_factory_->CreateAliasedFrame(captured_frame,
                                          cropped_width, cropped_height,
                                          adapted_width, adapted_height));
 
   if (!adapted_frame) {
     // TODO(fbarchard): LOG more information about captured frame attributes.
     LOG(LS_ERROR) << "Couldn't convert to I420! "
                   << "From " << ToString(captured_frame) << " To "
                   << cropped_width << " x " << cropped_height;
     return;
@@ skipping 17 matching lines @@
     return;
   }
   StateChangeParams* state_params = new StateChangeParams(state);
   capture_state_ = state;
   thread_->Post(this, MSG_STATE_CHANGE, state_params);
 }
 
 void VideoCapturer::OnMessage(rtc::Message* message) {
   switch (message->message_id) {
     case MSG_STATE_CHANGE: {
-      rtc::scoped_ptr<StateChangeParams> p(
+      std::unique_ptr<StateChangeParams> p(
           static_cast<StateChangeParams*>(message->pdata));
       SignalStateChange(this, p->data());
       break;
     }
     case MSG_DO_PAUSE: {
       Pause(true);
       break;
     }
     case MSG_DO_UNPAUSE: {
       Pause(false);
@@ skipping 154 matching lines @@
 void VideoCapturer::GetVariableSnapshot(
     const rtc::RollingAccumulator<T>& data,
     VariableInfo<T>* stats) {
   stats->max_val = data.ComputeMax();
   stats->mean = data.ComputeMean();
   stats->min_val = data.ComputeMin();
   stats->variance = data.ComputeVariance();
 }
 
 }  // namespace cricket