Replace scoped_ptr with std::unique_ptr in //media.

media/muxers/webm_muxer.cc

 // Copyright 2015 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 "media/muxers/webm_muxer.h"
 
 #include "base/bind.h"
+#include "base/memory/ptr_util.h"
 #include "media/base/audio_parameters.h"
 #include "media/base/limits.h"
 #include "media/base/video_frame.h"
 #include "media/filters/opus_constants.h"
 #include "ui/gfx/geometry/size.h"
 
 namespace media {
 
 namespace {
 
@@ skipping 81 matching lines @@
 }
 
 WebmMuxer::~WebmMuxer() {
   // No need to segment_.Finalize() since is not Seekable(), i.e. a live
   // stream, but is a good practice.
   DCHECK(thread_checker_.CalledOnValidThread());
   segment_.Finalize();
 }
 
 void WebmMuxer::OnEncodedVideo(const scoped_refptr<VideoFrame>& video_frame,
-                               scoped_ptr<std::string> encoded_data,
+                               std::unique_ptr<std::string> encoded_data,
                                base::TimeTicks timestamp,
                                bool is_key_frame) {
   DVLOG(1) << __FUNCTION__ << " - " << encoded_data->size() << "B";
   DCHECK(thread_checker_.CalledOnValidThread());
 
   if (!video_track_index_) {
     // |track_index_|, cannot be zero (!), initialize WebmMuxer in that case.
     // http://www.matroska.org/technical/specs/index.html#Tracks
     AddVideoTrack(video_frame->visible_rect().size(),
                   GetFrameRate(video_frame));
     if (first_frame_timestamp_video_.is_null())
       first_frame_timestamp_video_ = timestamp;
   }
 
   // TODO(ajose): Support multiple tracks: http://crbug.com/528523
   if (has_audio_ && !audio_track_index_) {
     DVLOG(1) << __FUNCTION__ << ": delaying until audio track ready.";
     if (is_key_frame)  // Upon Key frame reception, empty the encoded queue.
       encoded_frames_queue_.clear();
 
-    encoded_frames_queue_.push_back(make_scoped_ptr(new EncodedVideoFrame(
+    encoded_frames_queue_.push_back(base::WrapUnique(new EncodedVideoFrame(
         std::move(encoded_data), timestamp, is_key_frame)));
     return;
   }
 
   // Dump all saved encoded video frames if any.
   while (!encoded_frames_queue_.empty()) {
     AddFrame(
         std::move(encoded_frames_queue_.front()->data), video_track_index_,
         encoded_frames_queue_.front()->timestamp - first_frame_timestamp_video_,
         encoded_frames_queue_.front()->is_keyframe);
     encoded_frames_queue_.pop_front();
   }
 
   AddFrame(std::move(encoded_data), video_track_index_,
            timestamp - first_frame_timestamp_video_, is_key_frame);
 }
 
 void WebmMuxer::OnEncodedAudio(const media::AudioParameters& params,
-                               scoped_ptr<std::string> encoded_data,
+                               std::unique_ptr<std::string> encoded_data,
                                base::TimeTicks timestamp) {
   DVLOG(2) << __FUNCTION__ << " - " << encoded_data->size() << "B";
   DCHECK(thread_checker_.CalledOnValidThread());
 
   if (!audio_track_index_) {
     AddAudioTrack(params);
     if (first_frame_timestamp_audio_.is_null())
       first_frame_timestamp_audio_ = timestamp;
   }
 
@@ skipping 114 matching lines @@
   return false;
 }
 
 void WebmMuxer::ElementStartNotify(mkvmuxer::uint64 element_id,
                                    mkvmuxer::int64 position) {
   // This method gets pinged before items are sent to |write_data_callback_|.
   DCHECK_GE(position, position_.ValueOrDefault(0))
       << "Can't go back in a live WebM stream.";
 }
 
-void WebmMuxer::AddFrame(scoped_ptr<std::string> encoded_data,
+void WebmMuxer::AddFrame(std::unique_ptr<std::string> encoded_data,
                          uint8_t track_index,
                          base::TimeDelta timestamp,
                          bool is_key_frame) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(!has_video_ || video_track_index_);
   DCHECK(!has_audio_ || audio_track_index_);
 
   most_recent_timestamp_ =
       std::max(most_recent_timestamp_, timestamp - total_time_in_pause_);
 
   segment_.AddFrame(reinterpret_cast<const uint8_t*>(encoded_data->data()),
                     encoded_data->size(), track_index,
                     most_recent_timestamp_.InMicroseconds() *
                         base::Time::kNanosecondsPerMicrosecond,
                     is_key_frame);
 }
 
-WebmMuxer::EncodedVideoFrame::EncodedVideoFrame(scoped_ptr<std::string> data,
-                                                base::TimeTicks timestamp,
-                                                bool is_keyframe)
+WebmMuxer::EncodedVideoFrame::EncodedVideoFrame(
+    std::unique_ptr<std::string> data,
+    base::TimeTicks timestamp,
+    bool is_keyframe)
     : data(std::move(data)), timestamp(timestamp), is_keyframe(is_keyframe) {}
 
 WebmMuxer::EncodedVideoFrame::~EncodedVideoFrame() {}
 
 }  // namespace media