[Cast] EncodedAudioFrame+EncodedVideoFrame+reference_time --> EncodedFrame

media/cast/video_sender/video_encoder_impl_unittest.cc

 // Copyright 2014 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 <vector>
 
 #include "base/bind.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "media/base/video_frame.h"
 #include "media/cast/cast_defines.h"
 #include "media/cast/cast_environment.h"
 #include "media/cast/test/fake_single_thread_task_runner.h"
 #include "media/cast/test/utility/video_utility.h"
 #include "media/cast/video_sender/video_encoder_impl.h"
 #include "testing/gmock/include/gmock/gmock.h"
 
 namespace media {
 namespace cast {
 
 using testing::_;
 
 namespace {
 class TestVideoEncoderCallback
     : public base::RefCountedThreadSafe<TestVideoEncoderCallback> {
  public:
   TestVideoEncoderCallback() {}
 
-  void SetExpectedResult(bool expected_key_frame,
-                         uint8 expected_frame_id,
-                         uint8 expected_last_referenced_frame_id,
+  void SetExpectedResult(uint32 expected_frame_id,
+                         uint32 expected_last_referenced_frame_id,
                          const base::TimeTicks& expected_capture_time) {
-    expected_key_frame_ = expected_key_frame;
     expected_frame_id_ = expected_frame_id;
     expected_last_referenced_frame_id_ = expected_last_referenced_frame_id;
     expected_capture_time_ = expected_capture_time;
   }
 
   void DeliverEncodedVideoFrame(
-      scoped_ptr<transport::EncodedVideoFrame> encoded_frame,
-      const base::TimeTicks& capture_time) {
-    EXPECT_EQ(expected_key_frame_, encoded_frame->key_frame);
+      scoped_ptr<transport::EncodedFrame> encoded_frame) {
+    if (expected_frame_id_ == expected_last_referenced_frame_id_) {
+      EXPECT_EQ(transport::EncodedFrame::KEY, encoded_frame->dependency);
+    } else {
+      EXPECT_EQ(transport::EncodedFrame::DEPENDENT,
+                encoded_frame->dependency);
+    }
     EXPECT_EQ(expected_frame_id_, encoded_frame->frame_id);
     EXPECT_EQ(expected_last_referenced_frame_id_,
-              encoded_frame->last_referenced_frame_id);
-    EXPECT_EQ(expected_capture_time_, capture_time);
+              encoded_frame->referenced_frame_id);
+    EXPECT_EQ(expected_capture_time_, encoded_frame->reference_time);
   }
 
  protected:
   virtual ~TestVideoEncoderCallback() {}
 
  private:
   friend class base::RefCountedThreadSafe<TestVideoEncoderCallback>;
 
-  bool expected_key_frame_;
-  uint8 expected_frame_id_;
-  uint8 expected_last_referenced_frame_id_;
+  uint32 expected_frame_id_;
+  uint32 expected_last_referenced_frame_id_;
   base::TimeTicks expected_capture_time_;
 
   DISALLOW_COPY_AND_ASSIGN(TestVideoEncoderCallback);
 };
 }  // namespace
 
 class VideoEncoderImplTest : public ::testing::Test {
  protected:
   VideoEncoderImplTest()
       : test_video_encoder_callback_(new TestVideoEncoderCallback()) {
@@ skipping 53 matching lines @@
 
 TEST_F(VideoEncoderImplTest, EncodePattern30fpsRunningOutOfAck) {
   Configure(3);
 
   VideoEncoder::FrameEncodedCallback frame_encoded_callback =
       base::Bind(&TestVideoEncoderCallback::DeliverEncodedVideoFrame,
                  test_video_encoder_callback_.get());
 
   base::TimeTicks capture_time;
   capture_time += base::TimeDelta::FromMilliseconds(33);
-  test_video_encoder_callback_->SetExpectedResult(true, 0, 0, capture_time);
+  test_video_encoder_callback_->SetExpectedResult(0, 0, capture_time);
   EXPECT_TRUE(video_encoder_->EncodeVideoFrame(
       video_frame_, capture_time, frame_encoded_callback));
   task_runner_->RunTasks();
 
   capture_time += base::TimeDelta::FromMilliseconds(33);
   video_encoder_->LatestFrameIdToReference(0);
-  test_video_encoder_callback_->SetExpectedResult(false, 1, 0, capture_time);
+  test_video_encoder_callback_->SetExpectedResult(1, 0, capture_time);
   EXPECT_TRUE(video_encoder_->EncodeVideoFrame(
       video_frame_, capture_time, frame_encoded_callback));
   task_runner_->RunTasks();
 
   capture_time += base::TimeDelta::FromMilliseconds(33);
   video_encoder_->LatestFrameIdToReference(1);
-  test_video_encoder_callback_->SetExpectedResult(false, 2, 1, capture_time);
+  test_video_encoder_callback_->SetExpectedResult(2, 1, capture_time);
   EXPECT_TRUE(video_encoder_->EncodeVideoFrame(
       video_frame_, capture_time, frame_encoded_callback));
   task_runner_->RunTasks();
 
   video_encoder_->LatestFrameIdToReference(2);
 
   for (int i = 3; i < 6; ++i) {
     capture_time += base::TimeDelta::FromMilliseconds(33);
-    test_video_encoder_callback_->SetExpectedResult(false, i, 2, capture_time);
+    test_video_encoder_callback_->SetExpectedResult(i, 2, capture_time);
     EXPECT_TRUE(video_encoder_->EncodeVideoFrame(
         video_frame_, capture_time, frame_encoded_callback));
     task_runner_->RunTasks();
   }
 }
 
 // TODO(pwestin): Re-enabled after redesign the encoder to control number of
 // frames in flight.
 TEST_F(VideoEncoderImplTest, DISABLED_EncodePattern60fpsRunningOutOfAck) {
   video_config_.max_number_of_video_buffers_used = 1;
   Configure(6);
 
   base::TimeTicks capture_time;
   VideoEncoder::FrameEncodedCallback frame_encoded_callback =
       base::Bind(&TestVideoEncoderCallback::DeliverEncodedVideoFrame,
                  test_video_encoder_callback_.get());
 
   capture_time += base::TimeDelta::FromMilliseconds(33);
-  test_video_encoder_callback_->SetExpectedResult(true, 0, 0, capture_time);
+  test_video_encoder_callback_->SetExpectedResult(0, 0, capture_time);
   EXPECT_TRUE(video_encoder_->EncodeVideoFrame(
       video_frame_, capture_time, frame_encoded_callback));
   task_runner_->RunTasks();
 
   video_encoder_->LatestFrameIdToReference(0);
   capture_time += base::TimeDelta::FromMilliseconds(33);
-  test_video_encoder_callback_->SetExpectedResult(false, 1, 0, capture_time);
+  test_video_encoder_callback_->SetExpectedResult(1, 0, capture_time);
   EXPECT_TRUE(video_encoder_->EncodeVideoFrame(
       video_frame_, capture_time, frame_encoded_callback));
   task_runner_->RunTasks();
 
   video_encoder_->LatestFrameIdToReference(1);
   capture_time += base::TimeDelta::FromMilliseconds(33);
-  test_video_encoder_callback_->SetExpectedResult(false, 2, 0, capture_time);
+  test_video_encoder_callback_->SetExpectedResult(2, 0, capture_time);
   EXPECT_TRUE(video_encoder_->EncodeVideoFrame(
       video_frame_, capture_time, frame_encoded_callback));
   task_runner_->RunTasks();
 
   video_encoder_->LatestFrameIdToReference(2);
 
   for (int i = 3; i < 9; ++i) {
     capture_time += base::TimeDelta::FromMilliseconds(33);
-    test_video_encoder_callback_->SetExpectedResult(false, i, 2, capture_time);
+    test_video_encoder_callback_->SetExpectedResult(i, 2, capture_time);
     EXPECT_TRUE(video_encoder_->EncodeVideoFrame(
         video_frame_, capture_time, frame_encoded_callback));
     task_runner_->RunTasks();
   }
 }
 
 // TODO(pwestin): Re-enabled after redesign the encoder to control number of
 // frames in flight.
 TEST_F(VideoEncoderImplTest,
        DISABLED_EncodePattern60fps200msDelayRunningOutOfAck) {
   Configure(12);
 
   base::TimeTicks capture_time;
   VideoEncoder::FrameEncodedCallback frame_encoded_callback =
       base::Bind(&TestVideoEncoderCallback::DeliverEncodedVideoFrame,
                  test_video_encoder_callback_.get());
 
   capture_time += base::TimeDelta::FromMilliseconds(33);
-  test_video_encoder_callback_->SetExpectedResult(true, 0, 0, capture_time);
+  test_video_encoder_callback_->SetExpectedResult(0, 0, capture_time);
   EXPECT_TRUE(video_encoder_->EncodeVideoFrame(
       video_frame_, capture_time, frame_encoded_callback));
   task_runner_->RunTasks();
 
   video_encoder_->LatestFrameIdToReference(0);
   capture_time += base::TimeDelta::FromMilliseconds(33);
-  test_video_encoder_callback_->SetExpectedResult(false, 1, 0, capture_time);
+  test_video_encoder_callback_->SetExpectedResult(1, 0, capture_time);
   EXPECT_TRUE(video_encoder_->EncodeVideoFrame(
       video_frame_, capture_time, frame_encoded_callback));
   task_runner_->RunTasks();
 
   video_encoder_->LatestFrameIdToReference(1);
   capture_time += base::TimeDelta::FromMilliseconds(33);
-  test_video_encoder_callback_->SetExpectedResult(false, 2, 0, capture_time);
+  test_video_encoder_callback_->SetExpectedResult(2, 0, capture_time);
   EXPECT_TRUE(video_encoder_->EncodeVideoFrame(
       video_frame_, capture_time, frame_encoded_callback));
   task_runner_->RunTasks();
 
   video_encoder_->LatestFrameIdToReference(2);
   capture_time += base::TimeDelta::FromMilliseconds(33);
-  test_video_encoder_callback_->SetExpectedResult(false, 3, 0, capture_time);
+  test_video_encoder_callback_->SetExpectedResult(3, 0, capture_time);
   EXPECT_TRUE(video_encoder_->EncodeVideoFrame(
       video_frame_, capture_time, frame_encoded_callback));
   task_runner_->RunTasks();
 
   video_encoder_->LatestFrameIdToReference(3);
   capture_time += base::TimeDelta::FromMilliseconds(33);
-  test_video_encoder_callback_->SetExpectedResult(false, 4, 0, capture_time);
+  test_video_encoder_callback_->SetExpectedResult(4, 0, capture_time);
   EXPECT_TRUE(video_encoder_->EncodeVideoFrame(
       video_frame_, capture_time, frame_encoded_callback));
   task_runner_->RunTasks();
 
   video_encoder_->LatestFrameIdToReference(4);
 
   for (int i = 5; i < 17; ++i) {
-    test_video_encoder_callback_->SetExpectedResult(false, i, 4, capture_time);
+    test_video_encoder_callback_->SetExpectedResult(i, 4, capture_time);
     EXPECT_TRUE(video_encoder_->EncodeVideoFrame(
         video_frame_, capture_time, frame_encoded_callback));
     task_runner_->RunTasks();
   }
 }
 
 }  // namespace cast
 }  // namespace media