Remove implicit conversions from scoped_refptr to T* in media/

media/filters/source_buffer_stream.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 "media/filters/source_buffer_stream.h"
 
 #include <algorithm>
 #include <map>
 
 #include "base/bind.h"
@@ skipping 1131 matching lines @@
     // If we're about to delete the selected range, also reset the seek state.
     DCHECK((*itr)->GetStartTimestamp() >= duration_dts);
     if (*itr == selected_range_)
       ResetSeekState();
     DeleteAndRemoveRange(&itr);
   }
 }
 
 SourceBufferStream::Status SourceBufferStream::GetNextBuffer(
     scoped_refptr<StreamParserBuffer>* out_buffer) {
-  if (!pending_buffer_) {
+  if (!pending_buffer_.get()) {
     const SourceBufferStream::Status status = GetNextBufferInternal(out_buffer);
     if (status != SourceBufferStream::kSuccess || !SetPendingBuffer(out_buffer))
       return status;
   }
 
   if (!pending_buffer_->splice_buffers().empty())
     return HandleNextBufferWithSplice(out_buffer);
 
-  DCHECK(pending_buffer_->preroll_buffer());
+  DCHECK(pending_buffer_->preroll_buffer().get());
   return HandleNextBufferWithPreroll(out_buffer);
 }
 
 SourceBufferStream::Status SourceBufferStream::HandleNextBufferWithSplice(
     scoped_refptr<StreamParserBuffer>* out_buffer) {
   const BufferQueue& splice_buffers = pending_buffer_->splice_buffers();
   const size_t last_splice_buffer_index = splice_buffers.size() - 1;
 
   // Are there any splice buffers left to hand out?  The last buffer should be
   // handed out separately since it represents the first post-splice buffer.
   if (splice_buffers_index_ < last_splice_buffer_index) {
     // Account for config changes which occur between fade out buffers.
     if (current_config_index_ !=
         splice_buffers[splice_buffers_index_]->GetConfigId()) {
       config_change_pending_ = true;
       DVLOG(1) << "Config change (splice buffer config ID does not match).";
       return SourceBufferStream::kConfigChange;
     }
 
     // Every pre splice buffer must have the same splice_timestamp().
     DCHECK(pending_buffer_->splice_timestamp() ==
            splice_buffers[splice_buffers_index_]->splice_timestamp());
 
     // No pre splice buffers should have preroll.
-    DCHECK(!splice_buffers[splice_buffers_index_]->preroll_buffer());
+    DCHECK(!splice_buffers[splice_buffers_index_]->preroll_buffer().get());
 
     *out_buffer = splice_buffers[splice_buffers_index_++];
     return SourceBufferStream::kSuccess;
   }
 
   // Did we hand out the last pre-splice buffer on the previous call?
   if (!pending_buffers_complete_) {
     DCHECK_EQ(splice_buffers_index_, last_splice_buffer_index);
     pending_buffers_complete_ = true;
     config_change_pending_ = true;
@@ skipping 37 matching lines @@
 SourceBufferStream::Status SourceBufferStream::GetNextBufferInternal(
     scoped_refptr<StreamParserBuffer>* out_buffer) {
   CHECK(!config_change_pending_);
 
   if (!track_buffer_.empty()) {
     DCHECK(!selected_range_);
     scoped_refptr<StreamParserBuffer>& next_buffer = track_buffer_.front();
 
     // If the next buffer is an audio splice frame, the next effective config id
     // comes from the first splice buffer.
-    if (GetConfigId(next_buffer, 0) != current_config_index_) {
+    if (GetConfigId(next_buffer.get(), 0) != current_config_index_) {
       config_change_pending_ = true;
       DVLOG(1) << "Config change (track buffer config ID does not match).";
       return kConfigChange;
     }
 
     *out_buffer = next_buffer;
     track_buffer_.pop_front();
     last_output_buffer_timestamp_ = (*out_buffer)->GetDecodeTimestamp();
 
     // If the track buffer becomes empty, then try to set the selected range
@@ skipping 199 matching lines @@
   append_config_index_ = video_configs_.size();
   DVLOG(2) << "New video config - index: " << append_config_index_;
   video_configs_.resize(video_configs_.size() + 1);
   video_configs_[append_config_index_] = config;
   return true;
 }
 
 void SourceBufferStream::CompleteConfigChange() {
   config_change_pending_ = false;
 
-  if (pending_buffer_) {
+  if (pending_buffer_.get()) {
     current_config_index_ =
-        GetConfigId(pending_buffer_, splice_buffers_index_);
+        GetConfigId(pending_buffer_.get(), splice_buffers_index_);
     return;
   }
 
   if (!track_buffer_.empty()) {
-    current_config_index_ = GetConfigId(track_buffer_.front(), 0);
+    current_config_index_ = GetConfigId(track_buffer_.front().get(), 0);
     return;
   }
 
   if (selected_range_ && selected_range_->HasNextBuffer())
     current_config_index_ = selected_range_->GetNextConfigId();
 }
 
 void SourceBufferStream::SetSelectedRangeIfNeeded(
     const DecodeTimestamp timestamp) {
   DVLOG(1) << __FUNCTION__ << "(" << timestamp.InSecondsF() << ")";
@@ skipping 196 matching lines @@
   // a splice.
   for (size_t i = 0; i < pre_splice_buffers.size(); ++i) {
     const BufferQueue& original_splice_buffers =
         pre_splice_buffers[i]->splice_buffers();
     if (!original_splice_buffers.empty()) {
       DVLOG(1) << "Can't generate splice: overlapped buffers contain a "
                   "pre-existing splice.";
       return;
     }
 
-    if (pre_splice_buffers[i]->preroll_buffer()) {
+    if (pre_splice_buffers[i]->preroll_buffer().get()) {
       DVLOG(1) << "Can't generate splice: overlapped buffers contain preroll.";
       return;
     }
   }
 
   // Don't generate splice frames which represent less than two frames, since we
   // need at least that much to generate a crossfade.  Per the spec, make this
   // check using the sample rate of the overlapping buffers.
   const base::TimeDelta splice_duration =
       pre_splice_buffers.back()->timestamp() +
@@ skipping 383 matching lines @@
 
 bool SourceBufferRange::HasNextBuffer() const {
   return next_buffer_index_ >= 0 &&
       next_buffer_index_ < static_cast<int>(buffers_.size());
 }
 
 int SourceBufferRange::GetNextConfigId() const {
   DCHECK(HasNextBuffer());
   // If the next buffer is an audio splice frame, the next effective config id
   // comes from the first fade out preroll buffer.
-  return GetConfigId(buffers_[next_buffer_index_], 0);
+  return GetConfigId(buffers_[next_buffer_index_].get(), 0);
 }
 
 DecodeTimestamp SourceBufferRange::GetNextTimestamp() const {
   DCHECK(!buffers_.empty());
   DCHECK(HasNextBufferPosition());
 
   if (next_buffer_index_ >= static_cast<int>(buffers_.size())) {
     return kNoDecodeTimestamp();
   }
 
@@ skipping 159 matching lines @@
 
     if (buffer->timestamp() + buffer->duration() <= start.ToPresentationTime())
       continue;
     buffers->push_back(buffer);
   }
   return previous_size < buffers->size();
 }
 
 bool SourceBufferStream::SetPendingBuffer(
     scoped_refptr<StreamParserBuffer>* out_buffer) {
-  DCHECK(*out_buffer);
-  DCHECK(!pending_buffer_);
+  DCHECK(out_buffer->get());
+  DCHECK(!pending_buffer_.get());
 
   const bool have_splice_buffers = !(*out_buffer)->splice_buffers().empty();
-  const bool have_preroll_buffer = !!(*out_buffer)->preroll_buffer();
+  const bool have_preroll_buffer = !!(*out_buffer)->preroll_buffer().get();
 
   if (!have_splice_buffers && !have_preroll_buffer)
     return false;
 
   DCHECK_NE(have_splice_buffers, have_preroll_buffer);
   splice_buffers_index_ = 0;
   pending_buffer_.swap(*out_buffer);
   pending_buffers_complete_ = false;
   return true;
 }
 
 }  // namespace media