Delete method webrtc::VideoFrame::allocated_size and enum PlaneType.

webrtc/common_video/i420_video_frame_unittest.cc

 /*
  *  Copyright (c) 2012 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
 #include <math.h>
 #include <string.h>
 
 #include "testing/gtest/include/gtest/gtest.h"
 #include "webrtc/base/bind.h"
 #include "webrtc/test/fake_texture_frame.h"
 #include "webrtc/test/frame_utils.h"
 #include "webrtc/video_frame.h"
 
 namespace webrtc {
 
 namespace {
 
-int ExpectedSize(int plane_stride, int image_height, PlaneType type) {
-  if (type == kYPlane)
-    return plane_stride * image_height;
-  return plane_stride * ((image_height + 1) / 2);
-}
-
 rtc::scoped_refptr<I420Buffer> CreateGradient(int width, int height) {
   rtc::scoped_refptr<I420Buffer> buffer(
       I420Buffer::Create(width, height));
   // Initialize with gradient, Y = 128(x/w + y/h), U = 256 x/w, V = 256 y/h
   for (int x = 0; x < width; x++) {
     for (int y = 0; y < height; y++) {
       buffer->MutableDataY()[x + y * width] =
           128 * (x * height + y * width) / (width * height);
     }
   }
@@ skipping 63 matching lines @@
   EXPECT_EQ(valid_value, frame.width());
   EXPECT_EQ(valid_value, frame.height());
   frame.set_timestamp(123u);
   EXPECT_EQ(123u, frame.timestamp());
   frame.set_ntp_time_ms(456);
   EXPECT_EQ(456, frame.ntp_time_ms());
   frame.set_render_time_ms(789);
   EXPECT_EQ(789, frame.render_time_ms());
 }
 
-TEST(TestVideoFrame, SizeAllocation) {
-  VideoFrame frame;
-  frame. CreateEmptyFrame(10, 10, 12, 14, 220);
-  int height = frame.height();
-  int stride_y = frame.video_frame_buffer()->StrideY();
-  int stride_u = frame.video_frame_buffer()->StrideU();
-  int stride_v = frame.video_frame_buffer()->StrideV();
-  // Verify that allocated size was computed correctly.
-  EXPECT_EQ(ExpectedSize(stride_y, height, kYPlane),
-            frame.allocated_size(kYPlane));
-  EXPECT_EQ(ExpectedSize(stride_u, height, kUPlane),
-            frame.allocated_size(kUPlane));
-  EXPECT_EQ(ExpectedSize(stride_v, height, kVPlane),
-            frame.allocated_size(kVPlane));
-}
-
 TEST(TestVideoFrame, CopyFrame) {
   uint32_t timestamp = 1;
   int64_t ntp_time_ms = 2;
   int64_t render_time_ms = 3;
   int stride_y = 15;
   int stride_u = 10;
   int stride_v = 10;
   int width = 15;
   int height = 15;
   // Copy frame.
@@ skipping 108 matching lines @@
   frame2.CreateFrame(buffer_y, buffer_u, buffer_v,
                      width, height, stride_y, stride_uv, stride_uv,
                      kVideoRotation_0);
   // Expect exactly the same pixel data.
   EXPECT_TRUE(test::EqualPlane(buffer_y, frame2.video_frame_buffer()->DataY(),
                                stride_y, 15, 15));
   EXPECT_TRUE(test::EqualPlane(buffer_u, frame2.video_frame_buffer()->DataU(),
                                stride_uv, 8, 8));
   EXPECT_TRUE(test::EqualPlane(buffer_v, frame2.video_frame_buffer()->DataV(),
                                stride_uv, 8, 8));
-
-  // Compare size.
-  EXPECT_LE(kSizeY, frame2.allocated_size(kYPlane));
-  EXPECT_LE(kSizeUv, frame2.allocated_size(kUPlane));
-  EXPECT_LE(kSizeUv, frame2.allocated_size(kVPlane));
 }
 
 TEST(TestVideoFrame, FailToReuseAllocation) {
   VideoFrame frame1;
   frame1.CreateEmptyFrame(640, 320, 640, 320, 320);
   const uint8_t* y = frame1.video_frame_buffer()->DataY();
   const uint8_t* u = frame1.video_frame_buffer()->DataU();
   const uint8_t* v = frame1.video_frame_buffer()->DataV();
   // Make a shallow copy of |frame1|.
   VideoFrame frame2(frame1.video_frame_buffer(), 0, 0, kVideoRotation_0);
@@ skipping 90 matching lines @@
 
   // Center crop to 640 x 360 (16/9 aspect), then scale down by 2.
   rtc::scoped_refptr<I420Buffer> scaled_buffer(
       I420Buffer::Create(320, 180));
 
   scaled_buffer->CropAndScaleFrom(buf);
   CheckCrop(scaled_buffer, 0.0, 0.125, 1.0, 0.75);
 }
 
 }  // namespace webrtc