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

media/base/video_frame_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 "media/base/video_frame.h"
 
 #include "base/format_macros.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/stringprintf.h"
 #include "media/base/buffers.h"
@@ skipping 31 matching lines @@
 // makes sure that all the pixels of the RBG frame equal |expect_rgb_color|.
 void ExpectFrameColor(media::VideoFrame* yv12_frame, uint32 expect_rgb_color) {
   ASSERT_EQ(VideoFrame::YV12, yv12_frame->format());
   ASSERT_EQ(yv12_frame->stride(VideoFrame::kUPlane),
             yv12_frame->stride(VideoFrame::kVPlane));
 
   scoped_refptr<media::VideoFrame> rgb_frame;
   rgb_frame = media::VideoFrame::CreateFrame(VideoFrame::RGB32,
                                              yv12_frame->width(),
                                              yv12_frame->height(),
+                                             yv12_frame->natural_size(),
                                              yv12_frame->GetTimestamp());
 
   ASSERT_EQ(yv12_frame->width(), rgb_frame->width());
   ASSERT_EQ(yv12_frame->height(), rgb_frame->height());
 
   media::ConvertYUVToRGB32(yv12_frame->data(VideoFrame::kYPlane),
                            yv12_frame->data(VideoFrame::kUPlane),
                            yv12_frame->data(VideoFrame::kVPlane),
                            rgb_frame->data(VideoFrame::kRGBPlane),
                            rgb_frame->width(),
@@ skipping 19 matching lines @@
 // zero values.  Additionally, for the first plane verify the rows and
 // row_bytes values are correct.
 void ExpectFrameExtents(VideoFrame::Format format, int planes,
                         int bytes_per_pixel, const char* expected_hash) {
   const unsigned char kFillByte = 0x80;
   const size_t kWidth = 61;
   const size_t kHeight = 31;
   const base::TimeDelta kTimestamp = base::TimeDelta::FromMicroseconds(1337);
 
   scoped_refptr<VideoFrame> frame = VideoFrame::CreateFrame(
-      format, kWidth, kHeight, kTimestamp);
+      format, kWidth, kHeight, gfx::Size(kWidth, kHeight), kTimestamp);
   ASSERT_TRUE(frame);
 
   for(int plane = 0; plane < planes; plane++) {
     SCOPED_TRACE(base::StringPrintf("Checking plane %d", plane));
     EXPECT_TRUE(frame->data(plane));
     EXPECT_TRUE(frame->stride(plane));
     EXPECT_TRUE(frame->rows(plane));
     EXPECT_TRUE(frame->row_bytes(plane));
 
     if (plane == 0) {
@@ skipping 14 matching lines @@
 }
 
 TEST(VideoFrame, CreateFrame) {
   const size_t kWidth = 64;
   const size_t kHeight = 48;
   const base::TimeDelta kTimestamp = base::TimeDelta::FromMicroseconds(1337);
 
   // Create a YV12 Video Frame.
   scoped_refptr<media::VideoFrame> frame =
       VideoFrame::CreateFrame(media::VideoFrame::YV12, kWidth, kHeight,
-                              kTimestamp);
+                              gfx::Size(kWidth, kHeight), kTimestamp);
   ASSERT_TRUE(frame);
 
   // Test VideoFrame implementation.
   EXPECT_EQ(media::VideoFrame::YV12, frame->format());
   {
     SCOPED_TRACE("");
     InitializeYV12Frame(frame, 0.0f);
     ExpectFrameColor(frame, 0xFF000000);
   }
   base::MD5Digest digest;
@@ skipping 61 matching lines @@
   // ExpectFrameExtents).
   ExpectFrameExtents(
       VideoFrame::RGB32,  1, 4, "de6d3d567e282f6a38d478f04fc81fb0");
   ExpectFrameExtents(
       VideoFrame::YV12,   3, 1, "71113bdfd4c0de6cf62f48fb74f7a0b1");
   ExpectFrameExtents(
       VideoFrame::YV16,   3, 1, "9bb99ac3ff350644ebff4d28dc01b461");
 }
 
 }  // namespace media