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

media/cast/video_sender/external_video_encoder_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"
@@ skipping 27 matching lines @@
     return;
   }
   callback.Run(shm.Pass());
 }
 
 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->relationship);
+    } else {
+      EXPECT_EQ(transport::EncodedFrame::DEPENDENT,
+                encoded_frame->relationship);
+    }
     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 ExternalVideoEncoderTest : public ::testing::Test {
  protected:
   ExternalVideoEncoderTest()
       : test_video_encoder_callback_(new TestVideoEncoderCallback()) {
@@ skipping 51 matching lines @@
 
 TEST_F(ExternalVideoEncoderTest, EncodePattern30fpsRunningOutOfAck) {
   task_runner_->RunTasks();  // Run the initializer on the correct thread.
 
   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();
 
   for (int i = 0; i < 6; ++i) {
     capture_time += base::TimeDelta::FromMilliseconds(33);
-    test_video_encoder_callback_->SetExpectedResult(
-        false, i + 1, i, capture_time);
+    test_video_encoder_callback_->SetExpectedResult(i + 1, i, capture_time);
     EXPECT_TRUE(video_encoder_->EncodeVideoFrame(
         video_frame_, capture_time, frame_encoded_callback));
     task_runner_->RunTasks();
   }
   // We need to run the task to cleanup the GPU instance.
   video_encoder_.reset(NULL);
   task_runner_->RunTasks();
 }
 
 TEST_F(ExternalVideoEncoderTest, SkipNextFrame) {
   task_runner_->RunTasks();  // Run the initializer on the correct thread.
 
   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();
 
   video_encoder_->SkipNextFrame(true);
   for (int i = 0; i < 2; ++i) {
     capture_time += base::TimeDelta::FromMilliseconds(33);
     EXPECT_FALSE(video_encoder_->EncodeVideoFrame(
         video_frame_, capture_time, frame_encoded_callback));
     task_runner_->RunTasks();
   }
 
   video_encoder_->SkipNextFrame(false);
   for (int i = 0; i < 2; ++i) {
     capture_time += base::TimeDelta::FromMilliseconds(33);
-    test_video_encoder_callback_->SetExpectedResult(
-        false, i + 1, i, capture_time);
+    test_video_encoder_callback_->SetExpectedResult(i + 1, i, capture_time);
     EXPECT_TRUE(video_encoder_->EncodeVideoFrame(
         video_frame_, capture_time, frame_encoded_callback));
     task_runner_->RunTasks();
   }
   // We need to run the task to cleanup the GPU instance.
   video_encoder_.reset(NULL);
   task_runner_->RunTasks();
 }
 
 TEST_F(ExternalVideoEncoderTest, StreamHeader) {
   task_runner_->RunTasks();  // Run the initializer on the correct thread.
 
   VideoEncoder::FrameEncodedCallback frame_encoded_callback =
       base::Bind(&TestVideoEncoderCallback::DeliverEncodedVideoFrame,
                  test_video_encoder_callback_.get());
 
   // Force the FakeVideoEncodeAccelerator to return a dummy non-key frame first.
   fake_vea_->SendDummyFrameForTesting(false);
 
   // Verify the first returned bitstream buffer is still a key frame.
   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();
 
   // We need to run the task to cleanup the GPU instance.
   video_encoder_.reset(NULL);
   task_runner_->RunTasks();
 }
 
 }  // namespace cast
 }  // namespace media