Remove VideoDecoder::natural_size() & added VideoFrame::natural_size().

content/renderer/media/rtc_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 "content/renderer/media/rtc_video_decoder.h"
 
 #include <deque>
 
 #include "base/bind.h"
 #include "base/memory/singleton.h"
@@ skipping 204 matching lines @@
     decoder_->Initialize(
         NULL, NewExpectedStatusCB(PIPELINE_OK), NewStatisticsCB());
     message_loop_.RunAllPending();
   }
 
   StatisticsCB NewStatisticsCB() {
     return base::Bind(&MockStatisticsCB::OnStatistics,
                       base::Unretained(&statistics_cb_));
   }
 
+  void RenderFrame() {
+    NullVideoFrame video_frame;
+    decoder_->RenderFrame(&video_frame);
+  }
+
   MOCK_METHOD2(FrameReady, void(media::VideoDecoder::DecoderStatus status,
                                 const scoped_refptr<media::VideoFrame>&));
 
   // Fixture members.
   scoped_refptr<MockVideoTrack> video_track_;
   scoped_refptr<RTCVideoDecoder> decoder_;
   scoped_refptr<MockVideoRenderer> renderer_;
   MockStatisticsCB statistics_cb_;
   MessageLoop message_loop_;
   media::VideoDecoder::ReadCB read_cb_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(RTCVideoDecoderTest);
 };
 
 const int RTCVideoDecoderTest::kWidth = 640;
 const int RTCVideoDecoderTest::kHeight = 480;
 const PipelineStatistics RTCVideoDecoderTest::kStatistics;
 
+MATCHER_P2(HasSize, width, height, "") {
+  EXPECT_EQ(arg->data_size().width(), width);
+  EXPECT_EQ(arg->data_size().height(), height);
+  EXPECT_EQ(arg->natural_size().width(), width);
+  EXPECT_EQ(arg->natural_size().height(), height);
+  return (arg->data_size().width() == width) &&
+      (arg->data_size().height() == height) &&
+      (arg->natural_size().width() == width) &&
+      (arg->natural_size().height() == height);
+}
+
 TEST_F(RTCVideoDecoderTest, Initialize_Successful) {
   InitializeDecoderSuccessfully();
 
-  // Test that the output media format is an uncompressed video surface that
-  // matches the dimensions specified by RTC.
-  EXPECT_EQ(kWidth, decoder_->natural_size().width());
-  EXPECT_EQ(kHeight, decoder_->natural_size().height());
+  EXPECT_CALL(*this, FrameReady(media::VideoDecoder::kOk,
+                                HasSize(kWidth, kHeight)));
+  decoder_->Read(read_cb_);
+  RenderFrame();
 }
 
 TEST_F(RTCVideoDecoderTest, DoReset) {
   InitializeDecoderSuccessfully();
 
-  EXPECT_CALL(*this, FrameReady(media::VideoDecoder::kOk, _));
+  EXPECT_CALL(*this, FrameReady(media::VideoDecoder::kOk,
+                                scoped_refptr<media::VideoFrame>()));
   decoder_->Read(read_cb_);
   decoder_->Reset(media::NewExpectedClosure());
 
   message_loop_.RunAllPending();
   EXPECT_EQ(RTCVideoDecoder::kNormal, decoder_->state_);
 }
 
 TEST_F(RTCVideoDecoderTest, DoRenderFrame) {
   InitializeDecoderSuccessfully();
 
-  NullVideoFrame video_frame;
-
-  for (size_t i = 0; i < media::limits::kMaxVideoFrames; ++i) {
-    decoder_->RenderFrame(&video_frame);
-  }
+  for (size_t i = 0; i < media::limits::kMaxVideoFrames; ++i)
+    RenderFrame();
 
   message_loop_.RunAllPending();
   EXPECT_EQ(RTCVideoDecoder::kNormal, decoder_->state_);
 }
 
 TEST_F(RTCVideoDecoderTest, DoSetSize) {
   InitializeDecoderSuccessfully();
 
+  EXPECT_CALL(*this, FrameReady(media::VideoDecoder::kOk,
+                                HasSize(kWidth, kHeight)));
+  decoder_->Read(read_cb_);
+  RenderFrame();
+  message_loop_.RunAllPending();
+
   int new_width = kWidth * 2;
   int new_height = kHeight * 2;
-  gfx::Size new_natural_size(new_width, new_height);
-
   decoder_->SetSize(new_width, new_height);
 
-  EXPECT_EQ(new_width, decoder_->natural_size().width());
-  EXPECT_EQ(new_height, decoder_->natural_size().height());
-
+  EXPECT_CALL(*this, FrameReady(media::VideoDecoder::kOk,
+                                HasSize(new_width, new_height)));
+  decoder_->Read(read_cb_);
+  RenderFrame();
   message_loop_.RunAllPending();
 }
 
 TEST_F(RTCVideoDecoderTest, ReadAndShutdown) {
   // Test all the Read requests can be fullfilled (which is needed in order to
   // teardown the pipeline) even when there's no input frame.
   InitializeDecoderSuccessfully();
 
-  EXPECT_CALL(*this, FrameReady(media::VideoDecoder::kOk, _)).Times(2);
+  EXPECT_CALL(*this, FrameReady(media::VideoDecoder::kOk,
+                                scoped_refptr<media::VideoFrame>())).Times(2);
   decoder_->Read(read_cb_);
   EXPECT_FALSE(decoder_->shutting_down_);
   decoder_->PrepareForShutdownHack();
   EXPECT_TRUE(decoder_->shutting_down_);
   decoder_->Read(read_cb_);
 
   message_loop_.RunAllPending();
 }