Update media/ to use scoped_refptr<T>::get() rather than implicit "operator T*"

media/filters/ffmpeg_video_decoder_unittest.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 <string>
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/message_loop.h"
 #include "base/memory/singleton.h"
@@ skipping 21 matching lines @@
 using ::testing::StrictMock;
 
 namespace media {
 
 static const VideoFrame::Format kVideoFormat = VideoFrame::YV12;
 static const gfx::Size kCodedSize(320, 240);
 static const gfx::Rect kVisibleRect(320, 240);
 static const gfx::Size kNaturalSize(320, 240);
 
 ACTION_P(ReturnBuffer, buffer) {
-  arg0.Run(buffer ? DemuxerStream::kOk : DemuxerStream::kAborted, buffer);
+  arg0.Run(buffer.get() ? DemuxerStream::kOk : DemuxerStream::kAborted, buffer);
 }
 
 class FFmpegVideoDecoderTest : public testing::Test {
  public:
   FFmpegVideoDecoderTest()
       : decoder_(new FFmpegVideoDecoder(message_loop_.message_loop_proxy())),
         demuxer_(new StrictMock<MockDemuxerStream>(DemuxerStream::VIDEO)),
         read_cb_(base::Bind(&FFmpegVideoDecoderTest::FrameReady,
                             base::Unretained(this))) {
     FFmpegGlue::InitializeFFmpeg();
@@ skipping 42 matching lines @@
   }
 
   // Sets up expectations and actions to put FFmpegVideoDecoder in an active
   // decoding state.
   void EnterDecodingState() {
     VideoDecoder::Status status;
     scoped_refptr<VideoFrame> video_frame;
     DecodeSingleFrame(i_frame_buffer_, &status, &video_frame);
 
     EXPECT_EQ(VideoDecoder::kOk, status);
-    ASSERT_TRUE(video_frame);
+    ASSERT_TRUE(video_frame.get());
     EXPECT_FALSE(video_frame->IsEndOfStream());
   }
 
   // Sets up expectations and actions to put FFmpegVideoDecoder in an end
   // of stream state.
   void EnterEndOfStreamState() {
     scoped_refptr<VideoFrame> video_frame;
     VideoDecoder::Status status;
     Read(&status, &video_frame);
     EXPECT_EQ(VideoDecoder::kOk, status);
-    ASSERT_TRUE(video_frame);
+    ASSERT_TRUE(video_frame.get());
     EXPECT_TRUE(video_frame->IsEndOfStream());
   }
 
   // Decodes the single compressed frame in |buffer| and writes the
   // uncompressed output to |video_frame|. This method works with single
   // and multithreaded decoders. End of stream buffers are used to trigger
   // the frame to be returned in the multithreaded decoder case.
   void DecodeSingleFrame(const scoped_refptr<DecoderBuffer>& buffer,
                          VideoDecoder::Status* status,
                          scoped_refptr<VideoFrame>* video_frame) {
@@ skipping 28 matching lines @@
 
     EXPECT_CALL(statistics_cb_, OnStatistics(_))
         .Times(2);
 
     Read(&status_a, &video_frame_a);
     Read(&status_b, &video_frame_b);
 
     gfx::Size original_size = kVisibleRect.size();
     EXPECT_EQ(VideoDecoder::kOk, status_a);
     EXPECT_EQ(VideoDecoder::kOk, status_b);
-    ASSERT_TRUE(video_frame_a);
-    ASSERT_TRUE(video_frame_b);
+    ASSERT_TRUE(video_frame_a.get());
+    ASSERT_TRUE(video_frame_b.get());
     EXPECT_EQ(original_size.width(),
-        video_frame_a->visible_rect().size().width());
+              video_frame_a->visible_rect().size().width());
     EXPECT_EQ(original_size.height(),
         video_frame_a->visible_rect().size().height());
     EXPECT_EQ(expected_width, video_frame_b->visible_rect().size().width());
     EXPECT_EQ(expected_height, video_frame_b->visible_rect().size().height());
   }
 
   void Read(VideoDecoder::Status* status,
             scoped_refptr<VideoFrame>* video_frame) {
     EXPECT_CALL(*this, FrameReady(_, _))
         .WillOnce(DoAll(SaveArg<0>(status), SaveArg<1>(video_frame)));
@@ skipping 134 matching lines @@
 
 TEST_F(FFmpegVideoDecoderTest, DecodeFrame_Normal) {
   Initialize();
 
   // Simulate decoding a single frame.
   VideoDecoder::Status status;
   scoped_refptr<VideoFrame> video_frame;
   DecodeSingleFrame(i_frame_buffer_, &status, &video_frame);
 
   EXPECT_EQ(VideoDecoder::kOk, status);
-  ASSERT_TRUE(video_frame);
+  ASSERT_TRUE(video_frame.get());
   EXPECT_FALSE(video_frame->IsEndOfStream());
 }
 
 // Verify current behavior for 0 byte frames. FFmpeg simply ignores
 // the 0 byte frames.
 TEST_F(FFmpegVideoDecoderTest, DecodeFrame_0ByteFrame) {
   Initialize();
 
   scoped_refptr<DecoderBuffer> zero_byte_buffer = new DecoderBuffer(0);
 
@@ skipping 14 matching lines @@
       .Times(2);
 
   Read(&status_a, &video_frame_a);
   Read(&status_b, &video_frame_b);
   Read(&status_c, &video_frame_c);
 
   EXPECT_EQ(VideoDecoder::kOk, status_a);
   EXPECT_EQ(VideoDecoder::kOk, status_b);
   EXPECT_EQ(VideoDecoder::kOk, status_c);
 
-  ASSERT_TRUE(video_frame_a);
-  ASSERT_TRUE(video_frame_b);
-  ASSERT_TRUE(video_frame_c);
+  ASSERT_TRUE(video_frame_a.get());
+  ASSERT_TRUE(video_frame_b.get());
+  ASSERT_TRUE(video_frame_c.get());
 
   EXPECT_FALSE(video_frame_a->IsEndOfStream());
   EXPECT_FALSE(video_frame_b->IsEndOfStream());
   EXPECT_TRUE(video_frame_c->IsEndOfStream());
 }
 
 TEST_F(FFmpegVideoDecoderTest, DecodeFrame_DecodeError) {
   Initialize();
 
   EXPECT_CALL(*demuxer_, Read(_))
       .WillOnce(ReturnBuffer(corrupt_i_frame_buffer_))
       .WillRepeatedly(ReturnBuffer(i_frame_buffer_));
 
   // The error is only raised on the second decode attempt, so we expect at
   // least one successful decode but we don't expect FrameReady() to be
   // executed as an error is raised instead.
   EXPECT_CALL(statistics_cb_, OnStatistics(_));
 
   // Our read should still get satisfied with end of stream frame during an
   // error.
   VideoDecoder::Status status;
   scoped_refptr<VideoFrame> video_frame;
   Read(&status, &video_frame);
   EXPECT_EQ(VideoDecoder::kDecodeError, status);
-  EXPECT_FALSE(video_frame);
+  EXPECT_FALSE(video_frame.get());
 
   // After a decode error occurred, all following read will return kDecodeError.
   Read(&status, &video_frame);
   EXPECT_EQ(VideoDecoder::kDecodeError, status);
-  EXPECT_FALSE(video_frame);
+  EXPECT_FALSE(video_frame.get());
 }
 
 // Multi-threaded decoders have different behavior than single-threaded
 // decoders at the end of the stream. Multithreaded decoders hide errors
 // that happen on the last |codec_context_->thread_count| frames to avoid
 // prematurely signalling EOS. This test just exposes that behavior so we can
 // detect if it changes.
 TEST_F(FFmpegVideoDecoderTest, DecodeFrame_DecodeErrorAtEndOfStream) {
   Initialize();
 
   VideoDecoder::Status status;
   scoped_refptr<VideoFrame> video_frame;
   DecodeSingleFrame(corrupt_i_frame_buffer_, &status, &video_frame);
 
   EXPECT_EQ(VideoDecoder::kOk, status);
-  ASSERT_TRUE(video_frame);
+  ASSERT_TRUE(video_frame.get());
   EXPECT_TRUE(video_frame->IsEndOfStream());
 }
 
 // Decode |i_frame_buffer_| and then a frame with a larger width and verify
 // the output size was adjusted.
 TEST_F(FFmpegVideoDecoderTest, DecodeFrame_LargerWidth) {
   DecodeIFrameThenTestFile("vp8-I-frame-640x240", 640, 240);
 }
 
 // Decode |i_frame_buffer_| and then a frame with a smaller width and verify
@@ skipping 99 matching lines @@
 
   EXPECT_CALL(*demuxer_, Read(_))
       .WillOnce(ReturnBuffer(scoped_refptr<DecoderBuffer>()));
 
   VideoDecoder::Status status;
   scoped_refptr<VideoFrame> video_frame;
 
   Read(&status, &video_frame);
 
   EXPECT_EQ(VideoDecoder::kOk, status);
-  EXPECT_FALSE(video_frame);
+  EXPECT_FALSE(video_frame.get());
 }
 
 // Test aborted read on the demuxer stream during pending reset.
 TEST_F(FFmpegVideoDecoderTest, DemuxerRead_AbortedDuringReset) {
   Initialize();
 
   // Request a read on the decoder and ensure the demuxer has been called.
   DemuxerStream::ReadCB read_cb;
   EXPECT_CALL(*demuxer_, Read(_))
       .WillOnce(SaveArg<0>(&read_cb));
   decoder_->Read(read_cb_);
   ASSERT_FALSE(read_cb.is_null());
 
   // Reset while there is still an outstanding read on the demuxer.
   Reset();
 
   // Signal an aborted demuxer read: a NULL video frame should be returned.
   EXPECT_CALL(*this, FrameReady(VideoDecoder::kOk, IsNull()));
   read_cb.Run(DemuxerStream::kAborted, NULL);
   message_loop_.RunUntilIdle();
 }
 
 }  // namespace media