Remove implicit conversions from scoped_refptr to T* in media/

media/cast/sender/external_video_encoder.cc

 // Copyright 2014 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/cast/sender/external_video_encoder.h"
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/memory/scoped_vector.h"
 #include "base/memory/shared_memory.h"
@@ skipping 66 matching lines @@
     // we can properly destroy the VEA.
     create_vea_cb.Run(base::Bind(
         &LocalVideoEncodeAcceleratorClient::OnCreateVideoEncodeAcceleratorProxy,
         client));
 
     return client;
   }
 
   // Initialize the real HW encoder.
   void Initialize(const VideoSenderConfig& video_config) {
-    DCHECK(encoder_task_runner_);
+    DCHECK(encoder_task_runner_.get());
     DCHECK(encoder_task_runner_->RunsTasksOnCurrentThread());
 
     VideoCodecProfile output_profile = media::VIDEO_CODEC_PROFILE_UNKNOWN;
     switch (video_config.codec) {
       case CODEC_VIDEO_VP8:
         output_profile = media::VP8PROFILE_ANY;
         break;
       case CODEC_VIDEO_H264:
         output_profile = media::H264PROFILE_MAIN;
         break;
@@ skipping 19 matching lines @@
       NotifyError(VideoEncodeAccelerator::kInvalidArgumentError);
       return;
     }
 
     // Wait until shared memory is allocated to indicate that encoder is
     // initialized.
   }
 
   // Destroy the VEA on the correct thread.
   void Destroy() {
-    DCHECK(encoder_task_runner_);
+    DCHECK(encoder_task_runner_.get());
     if (!video_encode_accelerator_)
       return;
 
     if (encoder_task_runner_->RunsTasksOnCurrentThread()) {
       video_encode_accelerator_.reset();
     } else {
       // We do this instead of just reposting to encoder_task_runner_, because
       // we are called from the destructor.
       encoder_task_runner_->PostTask(
           FROM_HERE,
           base::Bind(&DestroyVideoEncodeAcceleratorOnEncoderThread,
                      base::Passed(&video_encode_accelerator_)));
     }
   }
 
   void SetBitRate(uint32 bit_rate) {
-    DCHECK(encoder_task_runner_);
+    DCHECK(encoder_task_runner_.get());
     DCHECK(encoder_task_runner_->RunsTasksOnCurrentThread());
 
     video_encode_accelerator_->RequestEncodingParametersChange(bit_rate,
                                                                max_frame_rate_);
   }
 
   void EncodeVideoFrame(
       const scoped_refptr<media::VideoFrame>& video_frame,
       const base::TimeTicks& capture_time,
       bool key_frame_requested,
       const VideoEncoder::FrameEncodedCallback& frame_encoded_callback) {
-    DCHECK(encoder_task_runner_);
+    DCHECK(encoder_task_runner_.get());
     DCHECK(encoder_task_runner_->RunsTasksOnCurrentThread());
 
     encoded_frame_data_storage_.push_back(
         EncodedFrameReturnData(capture_time, frame_encoded_callback));
 
     // BitstreamBufferReady will be called once the encoder is done.
     video_encode_accelerator_->Encode(video_frame, key_frame_requested);
   }
 
  protected:
   virtual void NotifyError(VideoEncodeAccelerator::Error error) OVERRIDE {
-    DCHECK(encoder_task_runner_);
+    DCHECK(encoder_task_runner_.get());
     DCHECK(encoder_task_runner_->RunsTasksOnCurrentThread());
     VLOG(1) << "ExternalVideoEncoder NotifyError: " << error;
 
     cast_environment_->PostTask(
         CastEnvironment::MAIN,
         FROM_HERE,
         base::Bind(&ExternalVideoEncoder::EncoderError, weak_owner_));
   }
 
   // Called to allocate the input and output buffers.
   virtual void RequireBitstreamBuffers(unsigned int input_count,
                                        const gfx::Size& input_coded_size,
                                        size_t output_buffer_size) OVERRIDE {
-    DCHECK(encoder_task_runner_);
+    DCHECK(encoder_task_runner_.get());
     DCHECK(encoder_task_runner_->RunsTasksOnCurrentThread());
     DCHECK(video_encode_accelerator_);
 
     for (size_t j = 0; j < kOutputBufferCount; ++j) {
       create_video_encode_memory_cb_.Run(
           output_buffer_size,
           base::Bind(&LocalVideoEncodeAcceleratorClient::OnCreateSharedMemory,
                      this));
     }
   }
 
   // Encoder has encoded a frame and it's available in one of out output
   // buffers.
   virtual void BitstreamBufferReady(int32 bitstream_buffer_id,
                                     size_t payload_size,
                                     bool key_frame) OVERRIDE {
-    DCHECK(encoder_task_runner_);
+    DCHECK(encoder_task_runner_.get());
     DCHECK(encoder_task_runner_->RunsTasksOnCurrentThread());
     if (bitstream_buffer_id < 0 ||
         bitstream_buffer_id >= static_cast<int32>(output_buffers_.size())) {
       NOTREACHED();
       VLOG(1) << "BitstreamBufferReady(): invalid bitstream_buffer_id="
               << bitstream_buffer_id;
       NotifyError(media::VideoEncodeAccelerator::kPlatformFailureError);
       return;
     }
     base::SharedMemory* output_buffer = output_buffers_[bitstream_buffer_id];
@@ skipping 105 matching lines @@
   // Note: This method can be called on any thread.
   void OnCreateSharedMemory(scoped_ptr<base::SharedMemory> memory) {
     encoder_task_runner_->PostTask(
         FROM_HERE,
         base::Bind(&LocalVideoEncodeAcceleratorClient::ReceivedSharedMemory,
                    this,
                    base::Passed(&memory)));
   }
 
   void ReceivedSharedMemory(scoped_ptr<base::SharedMemory> memory) {
-    DCHECK(encoder_task_runner_);
+    DCHECK(encoder_task_runner_.get());
     DCHECK(encoder_task_runner_->RunsTasksOnCurrentThread());
 
     output_buffers_.push_back(memory.release());
 
     // Wait until all requested buffers are received.
     if (output_buffers_.size() < kOutputBufferCount)
       return;
 
     // Immediately provide all output buffers to the VEA.
     for (size_t i = 0; i < output_buffers_.size(); ++i) {
@@ skipping 50 matching lines @@
       encoder_active_(false),
       key_frame_requested_(false),
       weak_factory_(this) {
   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
 
   video_accelerator_client_ =
       LocalVideoEncodeAcceleratorClient::Create(cast_environment_,
                                                 create_vea_cb,
                                                 create_video_encode_mem_cb,
                                                 weak_factory_.GetWeakPtr());
-  DCHECK(video_accelerator_client_);
+  DCHECK(video_accelerator_client_.get());
 }
 
 ExternalVideoEncoder::~ExternalVideoEncoder() {
 }
 
 void ExternalVideoEncoder::EncoderInitialized() {
   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
   encoder_active_ = true;
 }
 
@@ skipping 58 matching lines @@
   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
   key_frame_requested_ = true;
 }
 
 // Inform the encoder to only reference frames older or equal to frame_id;
 void ExternalVideoEncoder::LatestFrameIdToReference(uint32 /*frame_id*/) {
   // Do nothing not supported.
 }
 }  //  namespace cast
 }  //  namespace media