Revert of Replace the remaining scoped_ptr with unique_ptr in webrtc/modules/

webrtc/modules/rtp_rtcp/source/h264_bitstream_parser.cc

 /*
  *  Copyright (c) 2015 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.
  */
 #include "webrtc/modules/rtp_rtcp/source/h264_bitstream_parser.h"
 
-#include <memory>
 #include <vector>
 
 #include "webrtc/base/bitbuffer.h"
 #include "webrtc/base/bytebuffer.h"
 #include "webrtc/base/checks.h"
 #include "webrtc/base/logging.h"
+#include "webrtc/base/scoped_ptr.h"
 
 namespace webrtc {
 namespace {
 // The size of a NALU header {0 0 0 1}.
 static const size_t kNaluHeaderSize = 4;
 
 // The size of a NALU header plus the type byte.
 static const size_t kNaluHeaderAndTypeSize = kNaluHeaderSize + 1;
 
 // The NALU type.
@@ skipping 67 matching lines @@
 
 // These functions are similar to webrtc::H264SpsParser::Parse, and based on the
 // same version of the H.264 standard. You can find it here:
 // http://www.itu.int/rec/T-REC-H.264
 bool H264BitstreamParser::ParseSpsNalu(const uint8_t* sps, size_t length) {
   // Reset SPS state.
   sps_ = SpsState();
   sps_parsed_ = false;
   // Parse out the SPS RBSP. It should be small, so it's ok that we create a
   // copy. We'll eventually write this back.
-  std::unique_ptr<rtc::ByteBufferWriter> sps_rbsp(
+  rtc::scoped_ptr<rtc::ByteBufferWriter> sps_rbsp(
       ParseRbsp(sps + kNaluHeaderAndTypeSize, length - kNaluHeaderAndTypeSize));
   rtc::BitBuffer sps_parser(reinterpret_cast<const uint8_t*>(sps_rbsp->Data()),
                             sps_rbsp->Length());
 
   uint8_t byte_tmp;
   uint32_t golomb_tmp;
   uint32_t bits_tmp;
 
   // profile_idc: u(8).
   uint8_t profile_idc;
@@ skipping 85 matching lines @@
   RETURN_FALSE_ON_FAIL(sps_parser.ReadBits(&sps_.frame_mbs_only_flag, 1));
   sps_parsed_ = true;
   return true;
 }
 
 bool H264BitstreamParser::ParsePpsNalu(const uint8_t* pps, size_t length) {
   RTC_CHECK(sps_parsed_);
   // We're starting a new stream, so reset picture type rewriting values.
   pps_ = PpsState();
   pps_parsed_ = false;
-  std::unique_ptr<rtc::ByteBufferWriter> buffer(
+  rtc::scoped_ptr<rtc::ByteBufferWriter> buffer(
       ParseRbsp(pps + kNaluHeaderAndTypeSize, length - kNaluHeaderAndTypeSize));
   rtc::BitBuffer parser(reinterpret_cast<const uint8_t*>(buffer->Data()),
                         buffer->Length());
 
   uint32_t bits_tmp;
   uint32_t golomb_ignored;
   // pic_parameter_set_id: ue(v)
   RETURN_FALSE_ON_FAIL(parser.ReadExponentialGolomb(&golomb_ignored));
   // seq_parameter_set_id: ue(v)
   RETURN_FALSE_ON_FAIL(parser.ReadExponentialGolomb(&golomb_ignored));
@@ skipping 87 matching lines @@
   pps_parsed_ = true;
   return true;
 }
 
 bool H264BitstreamParser::ParseNonParameterSetNalu(const uint8_t* source,
                                                    size_t source_length,
                                                    uint8_t nalu_type) {
   RTC_CHECK(sps_parsed_);
   RTC_CHECK(pps_parsed_);
   last_slice_qp_delta_parsed_ = false;
-  std::unique_ptr<rtc::ByteBufferWriter> slice_rbsp(ParseRbsp(
+  rtc::scoped_ptr<rtc::ByteBufferWriter> slice_rbsp(ParseRbsp(
       source + kNaluHeaderAndTypeSize, source_length - kNaluHeaderAndTypeSize));
   rtc::BitBuffer slice_reader(
       reinterpret_cast<const uint8_t*>(slice_rbsp->Data()),
       slice_rbsp->Length());
   // Check to see if this is an IDR slice, which has an extra field to parse
   // out.
   bool is_idr = (source[kNaluHeaderSize] & 0x0F) == kNaluIdr;
   uint8_t nal_ref_idc = (source[kNaluHeaderSize] & 0x60) >> 5;
   uint32_t golomb_tmp;
   uint32_t bits_tmp;
@@ skipping 225 matching lines @@
 }
 
 bool H264BitstreamParser::GetLastSliceQp(int* qp) const {
   if (!last_slice_qp_delta_parsed_)
     return false;
   *qp = 26 + pps_.pic_init_qp_minus26 + last_slice_qp_delta_;
   return true;
 }
 
 }  // namespace webrtc