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

media/cast/test/end2end_unittest.cc

 // Copyright 2013 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.
 //
 // This test generate synthetic data. For audio it's a sinusoid waveform with
 // frequency kSoundFrequency and different amplitudes. For video it's a pattern
 // that is shifting by one pixel per frame, each pixels neighbors right and down
 // is this pixels value +1, since the pixel value is 8 bit it will wrap
 // frequently within the image. Visually this will create diagonally color bands
 // that moves across the screen
 
 #include <math.h>
 #include <stdint.h>
 
 #include <functional>
 #include <list>
 #include <map>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
-#include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/sys_byteorder.h"
 #include "base/test/simple_test_tick_clock.h"
 #include "base/time/tick_clock.h"
 #include "media/base/audio_bus.h"
 #include "media/base/video_frame.h"
 #include "media/cast/cast_config.h"
 #include "media/cast/cast_environment.h"
 #include "media/cast/cast_receiver.h"
 #include "media/cast/cast_sender.h"
@@ skipping 266 matching lines @@
         expected_audio_frame->record_time +
         base::TimeDelta::FromMilliseconds(kDefaultRtpMaxDelayMs +
                                           kTimerErrorMs);
     EXPECT_GE(upper_bound, playout_time)
         << "playout_time - upper_bound == "
         << (playout_time - upper_bound).InMicroseconds() << " usec";
 
     EXPECT_TRUE(is_continuous);
   }
 
-  void CheckCodedAudioFrame(
-      scoped_ptr<transport::EncodedAudioFrame> audio_frame,
-      const base::TimeTicks& playout_time) {
+  void CheckCodedAudioFrame(scoped_ptr<transport::EncodedFrame> audio_frame) {
     ASSERT_TRUE(!!audio_frame);
     ASSERT_FALSE(expected_frames_.empty());
     const ExpectedAudioFrame& expected_audio_frame =
         *(expected_frames_.front());
     // Note: Just peeking here.  Will delegate to CheckAudioFrame() to pop.
 
     // We need to "decode" the encoded audio frame.  The codec is simply to
     // swizzle the bytes of each int16 from host-->network-->host order to get
     // interleaved int16 PCM.  Then, make an AudioBus out of that.
     const int num_elements = audio_frame->data.size() / sizeof(int16);
     ASSERT_EQ(expected_audio_frame.audio_bus->channels() *
                   expected_audio_frame.audio_bus->frames(),
               num_elements);
     int16* const pcm_data =
-        reinterpret_cast<int16*>(string_as_array(&audio_frame->data));
+        reinterpret_cast<int16*>(audio_frame->mutable_bytes());
     for (int i = 0; i < num_elements; ++i)
       pcm_data[i] = static_cast<int16>(base::NetToHost16(pcm_data[i]));
     scoped_ptr<AudioBus> audio_bus(
         AudioBus::Create(expected_audio_frame.audio_bus->channels(),
                          expected_audio_frame.audio_bus->frames()));
     audio_bus->FromInterleaved(pcm_data, audio_bus->frames(), sizeof(int16));
 
     // Delegate the checking from here...
-    CheckAudioFrame(audio_bus.Pass(), playout_time, true);
+    CheckAudioFrame(audio_bus.Pass(), audio_frame->reference_time, true);
   }
 
   int number_times_called() const { return num_called_; }
 
  protected:
   virtual ~TestReceiverAudioCallback() {
     STLDeleteElements(&expected_frames_);
   }
 
  private:
@@ skipping 907 matching lines @@
   EXPECT_EQ(1000, received_counter);
 }
 
 // TODO(pwestin): Add repeatable packet loss test.
 // TODO(pwestin): Add test for misaligned send get calls.
 // TODO(pwestin): Add more tests that does not resample.
 // TODO(pwestin): Add test when we have starvation for our RunTask.
 
 }  // namespace cast
 }  // namespace media