Remove implicit conversions from scoped_refptr to T* in media/

media/filters/fake_video_decoder_unittest.cc

 // Copyright 2013 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 "base/basictypes.h"
 #include "base/bind.h"
 #include "base/message_loop/message_loop.h"
 #include "media/base/decoder_buffer.h"
 #include "media/base/mock_filters.h"
 #include "media/base/test_helpers.h"
@@ skipping 74 matching lines @@
   };
 
   void ExpectReadResult(CallbackResult result) {
     switch (result) {
       case PENDING:
         EXPECT_GT(pending_decode_requests_, 0);
         break;
       case OK:
         EXPECT_EQ(0, pending_decode_requests_);
         ASSERT_EQ(VideoDecoder::kOk, last_decode_status_);
-        ASSERT_TRUE(last_decoded_frame_);
+        ASSERT_TRUE(last_decoded_frame_.get());
         break;
       case NOT_ENOUGH_DATA:
         EXPECT_EQ(0, pending_decode_requests_);
         ASSERT_EQ(VideoDecoder::kOk, last_decode_status_);
-        ASSERT_FALSE(last_decoded_frame_);
+        ASSERT_FALSE(last_decoded_frame_.get());
         break;
       case ABORTED:
         EXPECT_EQ(0, pending_decode_requests_);
         ASSERT_EQ(VideoDecoder::kAborted, last_decode_status_);
-        EXPECT_FALSE(last_decoded_frame_);
+        EXPECT_FALSE(last_decoded_frame_.get());
         break;
     }
   }
 
   void Decode() {
     scoped_refptr<DecoderBuffer> buffer;
 
     if (num_input_buffers_ < kTotalBuffers) {
       buffer = CreateFakeVideoBufferForTest(
           current_config_,
           base::TimeDelta::FromMilliseconds(kDurationMs * num_input_buffers_),
           base::TimeDelta::FromMilliseconds(kDurationMs));
     } else {
       buffer = DecoderBuffer::CreateEOSBuffer();
     }
 
     ++num_input_buffers_;
     ++pending_decode_requests_;
 
     decoder_->Decode(
         buffer,
         base::Bind(&FakeVideoDecoderTest::DecodeDone, base::Unretained(this)));
     message_loop_.RunUntilIdle();
   }
 
   void ReadOneFrame() {
     last_decoded_frame_ = NULL;
     do {
       Decode();
-    } while (!last_decoded_frame_ && pending_decode_requests_ == 0);
+    } while (!last_decoded_frame_.get() && pending_decode_requests_ == 0);
   }
 
   void ReadAllFrames() {
     do {
       Decode();
     } while (num_input_buffers_ <= kTotalBuffers); // All input buffers + EOS.
   }
 
   void EnterPendingReadState() {
     // Pass the initial NOT_ENOUGH_DATA stage.
@@ skipping 121 matching lines @@
   if (GetParam().decoding_delay < 1)
     return;
 
   Initialize();
   decoder_->HoldDecode();
   ReadOneFrame();
   ExpectReadResult(PENDING);
   SatisfyDecodeAndExpect(NOT_ENOUGH_DATA);
 
   // Verify that FrameReady() hasn't been called.
-  EXPECT_FALSE(last_decoded_frame_);
+  EXPECT_FALSE(last_decoded_frame_.get());
 }
 
 TEST_P(FakeVideoDecoderTest, Read_Pending_OK) {
   Initialize();
   EnterPendingReadState();
   SatisfyDecodeAndExpect(OK);
 }
 
 TEST_P(FakeVideoDecoderTest, Read_Parallel) {
   if (GetParam().max_decode_requests < 2)
@@ skipping 102 matching lines @@
 }
 
 TEST_P(FakeVideoDecoderTest, Destroy_DuringPendingReadAndPendingReset) {
   Initialize();
   EnterPendingReadState();
   EnterPendingResetState();
   Destroy();
 }
 
 }  // namespace media