media/test/pipeline_integration_test.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "base/bind.h"
   6 #include "base/command_line.h"
   7 #include "base/memory/scoped_ptr.h"
   8 #include "base/strings/string_util.h"
   9 #include "build/build_config.h"
  10 #include "media/base/cdm_callback_promise.h"
  11 #include "media/base/cdm_context.h"
  12 #include "media/base/decoder_buffer.h"
  13 #include "media/base/media.h"
  14 #include "media/base/media_keys.h"
  15 #include "media/base/media_switches.h"
  16 #include "media/base/test_data_util.h"
  17 #include "media/cdm/aes_decryptor.h"
  18 #include "media/cdm/json_web_key.h"
  19 #include "media/filters/chunk_demuxer.h"
  20 #include "media/filters/renderer_impl.h"
  21 #include "media/test/pipeline_integration_test_base.h"
  22 #include "testing/gmock/include/gmock/gmock.h"
  23
  24 #if defined(MOJO_RENDERER)
  25 #include "media/mojo/services/mojo_renderer_impl.h"
  26 #include "mojo/public/cpp/application/application_impl.h"
  27 #include "mojo/public/cpp/application/application_test_base.h"
  28 #include "mojo/public/cpp/application/connect.h"
  29
  30 // TODO(dalecurtis): The mojo renderer is in another process, so we have no way
  31 // currently to get hashes for video and audio samples.  This also means that
  32 // real audio plays out for each test.
  33 #define EXPECT_HASH_EQ(a, b)
  34 #define EXPECT_VIDEO_FORMAT_EQ(a, b)
  35
  36 // TODO(xhwang): EME support is not complete for the mojo renderer, so all
  37 // encrypted tests are currently disabled.
  38 #define DISABLE_EME_TESTS 1
  39
  40 // TODO(xhwang,dalecurtis): Text tracks are not currently supported by the mojo
  41 // renderer.
  42 #define DISABLE_TEXT_TRACK_TESTS 1
  43 #else
  44 #define EXPECT_HASH_EQ(a, b) EXPECT_EQ(a, b)
  45 #define EXPECT_VIDEO_FORMAT_EQ(a, b) EXPECT_EQ(a, b)
  46 #endif
  47
  48 using testing::_;
  49 using testing::AnyNumber;
  50 using testing::AtLeast;
  51 using testing::AtMost;
  52 using testing::SaveArg;
  53
  54 namespace media {
  55
  56 const char kSourceId[] = "SourceId";
  57 const char kCencInitDataType[] = "cenc";
  58 const uint8 kInitData[] = { 0x69, 0x6e, 0x69, 0x74 };
  59
  60 const char kWebM[] = "video/webm; codecs=\"vp8,vorbis\"";
  61 const char kWebMVP9[] = "video/webm; codecs=\"vp9\"";
  62 const char kAudioOnlyWebM[] = "video/webm; codecs=\"vorbis\"";
  63 const char kOpusAudioOnlyWebM[] = "video/webm; codecs=\"opus\"";
  64 const char kVideoOnlyWebM[] = "video/webm; codecs=\"vp8\"";
  65 #if defined(USE_PROPRIETARY_CODECS)
  66 const char kADTS[] = "audio/aac";
  67 const char kMP4[] = "video/mp4; codecs=\"avc1.4D4041,mp4a.40.2\"";
  68 const char kMP4VideoAVC3[] = "video/mp4; codecs=\"avc3.64001f\"";
  69 #if !defined(DISABLE_EME_TESTS)
  70 const char kMP4Video[] = "video/mp4; codecs=\"avc1.4D4041\"";
  71 const char kMP4Audio[] = "audio/mp4; codecs=\"mp4a.40.2\"";
  72 #endif  // !defined(DISABLE_EME_TESTS)
  73 const char kMP3[] = "audio/mpeg";
  74 #endif  // defined(USE_PROPRIETARY_CODECS)
  75
  76 // Key used to encrypt test files.
  77 const uint8 kSecretKey[] = {
  78   0xeb, 0xdd, 0x62, 0xf1, 0x68, 0x14, 0xd2, 0x7b,
  79   0x68, 0xef, 0x12, 0x2a, 0xfc, 0xe4, 0xae, 0x3c
  80 };
  81
  82 // The key ID for all encrypted files.
  83 const uint8 kKeyId[] = {
  84   0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37,
  85   0x38, 0x39, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35
  86 };
  87
  88 const int kAppendWholeFile = -1;
  89
  90 // Constants for the Media Source config change tests.
  91 const int kAppendTimeSec = 1;
  92 const int kAppendTimeMs = kAppendTimeSec * 1000;
  93 const int k320WebMFileDurationMs = 2736;
  94 const int k640WebMFileDurationMs = 2749;
  95 const int kOpusEndTrimmingWebMFileDurationMs = 2741;
  96 const int kVP9WebMFileDurationMs = 2736;
  97 const int kVP8AWebMFileDurationMs = 2733;
  98
  99 #if defined(USE_PROPRIETARY_CODECS)
 100 #if !defined(DISABLE_EME_TESTS)
 101 const int k640IsoFileDurationMs = 2737;
 102 const int k640IsoCencFileDurationMs = 2736;
 103 #endif  // !defined(DISABLE_EME_TESTS)
 104 const int k1280IsoFileDurationMs = 2736;
 105 const int k1280IsoAVC3FileDurationMs = 2736;
 106 #endif  // defined(USE_PROPRIETARY_CODECS)
 107
 108 // Return a timeline offset for bear-320x240-live.webm.
 109 static base::Time kLiveTimelineOffset() {
 110   // The file contians the following UTC timeline offset:
 111   // 2012-11-10 12:34:56.789123456
 112   // Since base::Time only has a resolution of microseconds,
 113   // construct a base::Time for 2012-11-10 12:34:56.789123.
 114   base::Time::Exploded exploded_time;
 115   exploded_time.year = 2012;
 116   exploded_time.month = 11;
 117   exploded_time.day_of_month = 10;
 118   exploded_time.hour = 12;
 119   exploded_time.minute = 34;
 120   exploded_time.second = 56;
 121   exploded_time.millisecond = 789;
 122   base::Time timeline_offset = base::Time::FromUTCExploded(exploded_time);
 123
 124   timeline_offset += base::TimeDelta::FromMicroseconds(123);
 125
 126   return timeline_offset;
 127 }
 128
 129 // FFmpeg only supports time a resolution of seconds so this
 130 // helper function truncates a base::Time to seconds resolution.
 131 static base::Time TruncateToFFmpegTimeResolution(base::Time t) {
 132   base::Time::Exploded exploded_time;
 133   t.UTCExplode(&exploded_time);
 134   exploded_time.millisecond = 0;
 135
 136   return base::Time::FromUTCExploded(exploded_time);
 137 }
 138
 139 // Note: Tests using this class only exercise the DecryptingDemuxerStream path.
 140 // They do not exercise the Decrypting{Audio|Video}Decoder path.
 141 class FakeEncryptedMedia {
 142  public:
 143   // Defines the behavior of the "app" that responds to EME events.
 144   class AppBase {
 145    public:
 146     virtual ~AppBase() {}
 147
 148     virtual void OnSessionMessage(const std::string& web_session_id,
 149                                   const std::vector<uint8>& message,
 150                                   const GURL& destination_url) = 0;
 151
 152     virtual void OnSessionClosed(const std::string& web_session_id) = 0;
 153
 154     virtual void OnSessionKeysChange(const std::string& web_session_id,
 155                                      bool has_additional_usable_key) = 0;
 156
 157     // Errors are not expected unless overridden.
 158     virtual void OnSessionError(const std::string& web_session_id,
 159                                 const std::string& error_name,
 160                                 uint32 system_code,
 161                                 const std::string& error_message) {
 162       FAIL() << "Unexpected Key Error";
 163     }
 164
 165     virtual void OnEncryptedMediaInitData(const std::string& init_data_type,
 166                                           const std::vector<uint8>& init_data,
 167                                           AesDecryptor* decryptor) = 0;
 168   };
 169
 170   FakeEncryptedMedia(AppBase* app)
 171       : decryptor_(base::Bind(&FakeEncryptedMedia::OnSessionMessage,
 172                               base::Unretained(this)),
 173                    base::Bind(&FakeEncryptedMedia::OnSessionClosed,
 174                               base::Unretained(this)),
 175                    base::Bind(&FakeEncryptedMedia::OnSessionKeysChange,
 176                               base::Unretained(this))),
 177         cdm_context_(&decryptor_),
 178         app_(app) {}
 179
 180   CdmContext* GetCdmContext() { return &cdm_context_; }
 181
 182   // Callbacks for firing session events. Delegate to |app_|.
 183   void OnSessionMessage(const std::string& web_session_id,
 184                         const std::vector<uint8>& message,
 185                         const GURL& destination_url) {
 186     app_->OnSessionMessage(web_session_id, message, destination_url);
 187   }
 188
 189   void OnSessionClosed(const std::string& web_session_id) {
 190     app_->OnSessionClosed(web_session_id);
 191   }
 192
 193   void OnSessionKeysChange(const std::string& web_session_id,
 194                            bool has_additional_usable_key) {
 195     app_->OnSessionKeysChange(web_session_id, has_additional_usable_key);
 196   }
 197
 198   void OnSessionError(const std::string& web_session_id,
 199                       const std::string& error_name,
 200                       uint32 system_code,
 201                       const std::string& error_message) {
 202     app_->OnSessionError(
 203         web_session_id, error_name, system_code, error_message);
 204   }
 205
 206   void OnEncryptedMediaInitData(const std::string& init_data_type,
 207                                 const std::vector<uint8>& init_data) {
 208     app_->OnEncryptedMediaInitData(init_data_type, init_data, &decryptor_);
 209   }
 210
 211  private:
 212   class TestCdmContext : public CdmContext {
 213    public:
 214     TestCdmContext(Decryptor* decryptor) : decryptor_(decryptor) {}
 215
 216     Decryptor* GetDecryptor() final { return decryptor_; }
 217
 218 #if defined(ENABLE_BROWSER_CDMS)
 219     int GetCdmId() const final { return kInvalidCdmId; }
 220 #endif
 221
 222    private:
 223     Decryptor* decryptor_;
 224   };
 225
 226   AesDecryptor decryptor_;
 227   TestCdmContext cdm_context_;
 228   scoped_ptr<AppBase> app_;
 229 };
 230
 231 enum PromiseResult { RESOLVED, REJECTED };
 232
 233 // Provides |kSecretKey| in response to needkey.
 234 class KeyProvidingApp : public FakeEncryptedMedia::AppBase {
 235  public:
 236   KeyProvidingApp() {}
 237
 238   void OnResolveWithSession(PromiseResult expected,
 239                             const std::string& web_session_id) {
 240     EXPECT_EQ(expected, RESOLVED);
 241     EXPECT_GT(web_session_id.length(), 0ul);
 242     current_session_id_ = web_session_id;
 243   }
 244
 245   void OnResolve(PromiseResult expected) {
 246     EXPECT_EQ(expected, RESOLVED);
 247   }
 248
 249   void OnReject(PromiseResult expected,
 250                 media::MediaKeys::Exception exception_code,
 251                 uint32 system_code,
 252                 const std::string& error_message) {
 253     EXPECT_EQ(expected, REJECTED);
 254   }
 255
 256   scoped_ptr<SimpleCdmPromise> CreatePromise(PromiseResult expected) {
 257     scoped_ptr<media::SimpleCdmPromise> promise(new media::CdmCallbackPromise<>(
 258         base::Bind(
 259             &KeyProvidingApp::OnResolve, base::Unretained(this), expected),
 260         base::Bind(
 261             &KeyProvidingApp::OnReject, base::Unretained(this), expected)));
 262     return promise.Pass();
 263   }
 264
 265   scoped_ptr<NewSessionCdmPromise> CreateSessionPromise(
 266       PromiseResult expected) {
 267     scoped_ptr<media::NewSessionCdmPromise> promise(
 268         new media::CdmCallbackPromise<std::string>(
 269             base::Bind(&KeyProvidingApp::OnResolveWithSession,
 270                        base::Unretained(this),
 271                        expected),
 272             base::Bind(
 273                 &KeyProvidingApp::OnReject, base::Unretained(this), expected)));
 274     return promise.Pass();
 275   }
 276
 277   void OnSessionMessage(const std::string& web_session_id,
 278                         const std::vector<uint8>& message,
 279                         const GURL& destination_url) override {
 280     EXPECT_FALSE(web_session_id.empty());
 281     EXPECT_FALSE(message.empty());
 282     EXPECT_EQ(current_session_id_, web_session_id);
 283   }
 284
 285   void OnSessionClosed(const std::string& web_session_id) override {
 286     EXPECT_EQ(current_session_id_, web_session_id);
 287   }
 288
 289   void OnSessionKeysChange(const std::string& web_session_id,
 290                            bool has_additional_usable_key) override {
 291     EXPECT_EQ(current_session_id_, web_session_id);
 292     EXPECT_EQ(has_additional_usable_key, true);
 293   }
 294
 295   void OnEncryptedMediaInitData(const std::string& init_data_type,
 296                                 const std::vector<uint8>& init_data,
 297                                 AesDecryptor* decryptor) override {
 298     if (current_session_id_.empty()) {
 299       decryptor->CreateSession(init_data_type, kInitData, arraysize(kInitData),
 300                                MediaKeys::TEMPORARY_SESSION,
 301                                CreateSessionPromise(RESOLVED));
 302       EXPECT_FALSE(current_session_id_.empty());
 303     }
 304
 305     // Clear Key really needs the key ID in |init_data|. For WebM, they are the
 306     // same, but this is not the case for ISO CENC. Therefore, provide the
 307     // correct key ID.
 308     const uint8* key_id = init_data.empty() ? NULL : &init_data[0];
 309     size_t key_id_length = init_data.size();
 310     if (init_data_type == kCencInitDataType) {
 311       key_id = kKeyId;
 312       key_id_length = arraysize(kKeyId);
 313     }
 314
 315     // Convert key into a JSON structure and then add it.
 316     std::string jwk = GenerateJWKSet(
 317         kSecretKey, arraysize(kSecretKey), key_id, key_id_length);
 318     decryptor->UpdateSession(current_session_id_,
 319                              reinterpret_cast<const uint8*>(jwk.data()),
 320                              jwk.size(),
 321                              CreatePromise(RESOLVED));
 322   }
 323
 324   std::string current_session_id_;
 325 };
 326
 327 class RotatingKeyProvidingApp : public KeyProvidingApp {
 328  public:
 329   RotatingKeyProvidingApp() : num_distint_need_key_calls_(0) {}
 330   ~RotatingKeyProvidingApp() override {
 331     // Expect that OnEncryptedMediaInitData is fired multiple times with
 332     // different |init_data|.
 333     EXPECT_GT(num_distint_need_key_calls_, 1u);
 334   }
 335
 336   void OnEncryptedMediaInitData(const std::string& init_data_type,
 337                                 const std::vector<uint8>& init_data,
 338                                 AesDecryptor* decryptor) override {
 339     // Skip the request if the |init_data| has been seen.
 340     if (init_data == prev_init_data_)
 341       return;
 342     prev_init_data_ = init_data;
 343     ++num_distint_need_key_calls_;
 344
 345     decryptor->CreateSession(init_data_type, vector_as_array(&init_data),
 346                              init_data.size(), MediaKeys::TEMPORARY_SESSION,
 347                              CreateSessionPromise(RESOLVED));
 348
 349     std::vector<uint8> key_id;
 350     std::vector<uint8> key;
 351     EXPECT_TRUE(GetKeyAndKeyId(init_data, &key, &key_id));
 352
 353     // Convert key into a JSON structure and then add it.
 354     std::string jwk = GenerateJWKSet(vector_as_array(&key),
 355                                      key.size(),
 356                                      vector_as_array(&key_id),
 357                                      key_id.size());
 358     decryptor->UpdateSession(current_session_id_,
 359                              reinterpret_cast<const uint8*>(jwk.data()),
 360                              jwk.size(),
 361                              CreatePromise(RESOLVED));
 362   }
 363
 364  private:
 365   bool GetKeyAndKeyId(std::vector<uint8> init_data,
 366                       std::vector<uint8>* key,
 367                       std::vector<uint8>* key_id) {
 368     // For WebM, init_data is key_id; for ISO CENC, init_data should contain
 369     // the key_id. We assume key_id is in the end of init_data here (that is
 370     // only a reasonable assumption for WebM and clear key ISO CENC).
 371     DCHECK_GE(init_data.size(), arraysize(kKeyId));
 372     std::vector<uint8> key_id_from_init_data(
 373         init_data.end() - arraysize(kKeyId), init_data.end());
 374
 375     key->assign(kSecretKey, kSecretKey + arraysize(kSecretKey));
 376     key_id->assign(kKeyId, kKeyId + arraysize(kKeyId));
 377
 378     // The Key and KeyId for this testing key provider are created by left
 379     // rotating kSecretKey and kKeyId. Note that this implementation is only
 380     // intended for testing purpose. The actual key rotation algorithm can be
 381     // much more complicated.
 382     // Find out the rotating position from |key_id_from_init_data| and apply on
 383     // |key|.
 384     for (size_t pos = 0; pos < arraysize(kKeyId); ++pos) {
 385       std::rotate(key_id->begin(), key_id->begin() + pos, key_id->end());
 386       if (*key_id == key_id_from_init_data) {
 387         std::rotate(key->begin(), key->begin() + pos, key->end());
 388         return true;
 389       }
 390     }
 391     return false;
 392   }
 393
 394   std::vector<uint8> prev_init_data_;
 395   uint32 num_distint_need_key_calls_;
 396 };
 397
 398 // Ignores needkey and does not perform a license request
 399 class NoResponseApp : public FakeEncryptedMedia::AppBase {
 400  public:
 401   void OnSessionMessage(const std::string& web_session_id,
 402                         const std::vector<uint8>& message,
 403                         const GURL& default_url) override {
 404     EXPECT_FALSE(web_session_id.empty());
 405     EXPECT_FALSE(message.empty());
 406     FAIL() << "Unexpected Message";
 407   }
 408
 409   void OnSessionClosed(const std::string& web_session_id) override {
 410     EXPECT_FALSE(web_session_id.empty());
 411     FAIL() << "Unexpected Closed";
 412   }
 413
 414   void OnSessionKeysChange(const std::string& web_session_id,
 415                            bool has_additional_usable_key) override {
 416     EXPECT_FALSE(web_session_id.empty());
 417     EXPECT_EQ(has_additional_usable_key, true);
 418   }
 419
 420   void OnEncryptedMediaInitData(const std::string& init_data_type,
 421                                 const std::vector<uint8>& init_data,
 422                                 AesDecryptor* decryptor) override {}
 423 };
 424
 425 // Helper class that emulates calls made on the ChunkDemuxer by the
 426 // Media Source API.
 427 class MockMediaSource {
 428  public:
 429   MockMediaSource(const std::string& filename,
 430                   const std::string& mimetype,
 431                   int initial_append_size)
 432       : current_position_(0),
 433         initial_append_size_(initial_append_size),
 434         mimetype_(mimetype),
 435         chunk_demuxer_(new ChunkDemuxer(
 436             base::Bind(&MockMediaSource::DemuxerOpened, base::Unretained(this)),
 437             base::Bind(&MockMediaSource::OnEncryptedMediaInitData,
 438                        base::Unretained(this)),
 439             LogCB(),
 440             scoped_refptr<MediaLog>(new MediaLog()),
 441             true)),
 442         owned_chunk_demuxer_(chunk_demuxer_) {
 443     file_data_ = ReadTestDataFile(filename);
 444
 445     if (initial_append_size_ == kAppendWholeFile)
 446       initial_append_size_ = file_data_->data_size();
 447
 448     DCHECK_GT(initial_append_size_, 0);
 449     DCHECK_LE(initial_append_size_, file_data_->data_size());
 450   }
 451
 452   virtual ~MockMediaSource() {}
 453
 454   scoped_ptr<Demuxer> GetDemuxer() { return owned_chunk_demuxer_.Pass(); }
 455
 456   void set_encrypted_media_init_data_cb(
 457       const Demuxer::EncryptedMediaInitDataCB& encrypted_media_init_data_cb) {
 458     encrypted_media_init_data_cb_ = encrypted_media_init_data_cb;
 459   }
 460
 461   void Seek(base::TimeDelta seek_time, int new_position, int seek_append_size) {
 462     chunk_demuxer_->StartWaitingForSeek(seek_time);
 463
 464     chunk_demuxer_->Abort(
 465         kSourceId,
 466         base::TimeDelta(), kInfiniteDuration(), &last_timestamp_offset_);
 467
 468     DCHECK_GE(new_position, 0);
 469     DCHECK_LT(new_position, file_data_->data_size());
 470     current_position_ = new_position;
 471
 472     AppendData(seek_append_size);
 473   }
 474
 475   void AppendData(int size) {
 476     DCHECK(chunk_demuxer_);
 477     DCHECK_LT(current_position_, file_data_->data_size());
 478     DCHECK_LE(current_position_ + size, file_data_->data_size());
 479
 480     chunk_demuxer_->AppendData(
 481         kSourceId, file_data_->data() + current_position_, size,
 482         base::TimeDelta(), kInfiniteDuration(), &last_timestamp_offset_,
 483         base::Bind(&MockMediaSource::InitSegmentReceived,
 484                    base::Unretained(this)));
 485     current_position_ += size;
 486   }
 487
 488   void AppendAtTime(base::TimeDelta timestamp_offset,
 489                     const uint8* pData,
 490                     int size) {
 491     CHECK(!chunk_demuxer_->IsParsingMediaSegment(kSourceId));
 492     chunk_demuxer_->AppendData(kSourceId, pData, size,
 493                                base::TimeDelta(), kInfiniteDuration(),
 494                                &timestamp_offset,
 495                                base::Bind(&MockMediaSource::InitSegmentReceived,
 496                                           base::Unretained(this)));
 497     last_timestamp_offset_ = timestamp_offset;
 498   }
 499
 500   void AppendAtTimeWithWindow(base::TimeDelta timestamp_offset,
 501                               base::TimeDelta append_window_start,
 502                               base::TimeDelta append_window_end,
 503                               const uint8* pData,
 504                               int size) {
 505     CHECK(!chunk_demuxer_->IsParsingMediaSegment(kSourceId));
 506     chunk_demuxer_->AppendData(kSourceId,
 507                                pData,
 508                                size,
 509                                append_window_start,
 510                                append_window_end,
 511                                &timestamp_offset,
 512                                base::Bind(&MockMediaSource::InitSegmentReceived,
 513                                           base::Unretained(this)));
 514     last_timestamp_offset_ = timestamp_offset;
 515   }
 516
 517   void EndOfStream() {
 518     chunk_demuxer_->MarkEndOfStream(PIPELINE_OK);
 519   }
 520
 521   void Abort() {
 522     if (!chunk_demuxer_)
 523       return;
 524     chunk_demuxer_->Shutdown();
 525     chunk_demuxer_ = NULL;
 526   }
 527
 528   void DemuxerOpened() {
 529     base::MessageLoop::current()->PostTask(
 530         FROM_HERE, base::Bind(&MockMediaSource::DemuxerOpenedTask,
 531                               base::Unretained(this)));
 532   }
 533
 534   void DemuxerOpenedTask() {
 535     // This code assumes that |mimetype_| is one of the following forms.
 536     // 1. audio/mpeg
 537     // 2. video/webm;codec="vorbis,vp8".
 538     size_t semicolon = mimetype_.find(";");
 539     std::string type = mimetype_;
 540     std::vector<std::string> codecs;
 541     if (semicolon != std::string::npos) {
 542       type = mimetype_.substr(0, semicolon);
 543       size_t codecs_param_start = mimetype_.find("codecs=\"", semicolon);
 544
 545       CHECK_NE(codecs_param_start, std::string::npos);
 546
 547       codecs_param_start += 8; // Skip over the codecs=".
 548
 549       size_t codecs_param_end = mimetype_.find("\"", codecs_param_start);
 550
 551       CHECK_NE(codecs_param_end, std::string::npos);
 552
 553       std::string codecs_param =
 554           mimetype_.substr(codecs_param_start,
 555                            codecs_param_end - codecs_param_start);
 556       Tokenize(codecs_param, ",", &codecs);
 557     }
 558
 559     CHECK_EQ(chunk_demuxer_->AddId(kSourceId, type, codecs), ChunkDemuxer::kOk);
 560
 561     AppendData(initial_append_size_);
 562   }
 563
 564   void OnEncryptedMediaInitData(const std::string& init_data_type,
 565                                 const std::vector<uint8>& init_data) {
 566     DCHECK(!init_data.empty());
 567     CHECK(!encrypted_media_init_data_cb_.is_null());
 568     encrypted_media_init_data_cb_.Run(init_data_type, init_data);
 569   }
 570
 571   base::TimeDelta last_timestamp_offset() const {
 572     return last_timestamp_offset_;
 573   }
 574
 575   MOCK_METHOD0(InitSegmentReceived, void(void));
 576
 577  private:
 578   scoped_refptr<DecoderBuffer> file_data_;
 579   int current_position_;
 580   int initial_append_size_;
 581   std::string mimetype_;
 582   ChunkDemuxer* chunk_demuxer_;
 583   scoped_ptr<Demuxer> owned_chunk_demuxer_;
 584   Demuxer::EncryptedMediaInitDataCB encrypted_media_init_data_cb_;
 585   base::TimeDelta last_timestamp_offset_;
 586 };
 587
 588 #if defined(MOJO_RENDERER)
 589 class PipelineIntegrationTestHost : public mojo::test::ApplicationTestBase,
 590                                     public PipelineIntegrationTestBase {
 591  public:
 592   bool ShouldCreateDefaultRunLoop() override { return false; }
 593
 594   void SetUp() override {
 595     ApplicationTestBase::SetUp();
 596
 597     // TODO(dalecurtis): For some reason this isn't done...
 598     if (!base::CommandLine::InitializedForCurrentProcess()) {
 599       base::CommandLine::Init(0, NULL);
 600       InitializeMediaLibraryForTesting();
 601     }
 602   }
 603
 604  protected:
 605   scoped_ptr<Renderer> CreateRenderer() override {
 606     mojo::ServiceProvider* service_provider =
 607         application_impl()
 608             ->ConnectToApplication("mojo://media")
 609             ->GetServiceProvider();
 610
 611     mojo::MediaRendererPtr mojo_media_renderer;
 612     mojo::ConnectToService(service_provider, &mojo_media_renderer);
 613     return make_scoped_ptr(new MojoRendererImpl(message_loop_.task_runner(),
 614                                                 mojo_media_renderer.Pass()));
 615   }
 616 };
 617 #else
 618 class PipelineIntegrationTestHost : public testing::Test,
 619                                     public PipelineIntegrationTestBase {};
 620 #endif
 621
 622 class PipelineIntegrationTest : public PipelineIntegrationTestHost {
 623  public:
 624   void StartPipelineWithMediaSource(MockMediaSource* source) {
 625     EXPECT_CALL(*source, InitSegmentReceived()).Times(AtLeast(1));
 626     EXPECT_CALL(*this, OnMetadata(_))
 627         .Times(AtMost(1))
 628         .WillRepeatedly(SaveArg<0>(&metadata_));
 629     EXPECT_CALL(*this, OnBufferingStateChanged(BUFFERING_HAVE_ENOUGH))
 630         .Times(AtMost(1));
 631     demuxer_ = source->GetDemuxer().Pass();
 632     pipeline_->Start(
 633         demuxer_.get(), CreateRenderer(),
 634         base::Bind(&PipelineIntegrationTest::OnEnded, base::Unretained(this)),
 635         base::Bind(&PipelineIntegrationTest::OnError, base::Unretained(this)),
 636         base::Bind(&PipelineIntegrationTest::OnStatusCallback,
 637                    base::Unretained(this)),
 638         base::Bind(&PipelineIntegrationTest::OnMetadata,
 639                    base::Unretained(this)),
 640         base::Bind(&PipelineIntegrationTest::OnBufferingStateChanged,
 641                    base::Unretained(this)),
 642         base::Bind(&PipelineIntegrationTest::OnVideoFramePaint,
 643                    base::Unretained(this)),
 644         base::Closure(), base::Bind(&PipelineIntegrationTest::OnAddTextTrack,
 645                                     base::Unretained(this)));
 646     message_loop_.Run();
 647     EXPECT_EQ(PIPELINE_OK, pipeline_status_);
 648   }
 649
 650   void StartHashedPipelineWithMediaSource(MockMediaSource* source) {
 651     hashing_enabled_ = true;
 652     StartPipelineWithMediaSource(source);
 653   }
 654
 655   void StartPipelineWithEncryptedMedia(
 656       MockMediaSource* source,
 657       FakeEncryptedMedia* encrypted_media) {
 658     EXPECT_CALL(*source, InitSegmentReceived()).Times(AtLeast(1));
 659     EXPECT_CALL(*this, OnMetadata(_))
 660         .Times(AtMost(1))
 661         .WillRepeatedly(SaveArg<0>(&metadata_));
 662     EXPECT_CALL(*this, OnBufferingStateChanged(BUFFERING_HAVE_ENOUGH))
 663         .Times(AtMost(1));
 664     EXPECT_CALL(*this, DecryptorAttached(true));
 665
 666     demuxer_ = source->GetDemuxer().Pass();
 667
 668     pipeline_->SetCdm(encrypted_media->GetCdmContext(),
 669                       base::Bind(&PipelineIntegrationTest::DecryptorAttached,
 670                                  base::Unretained(this)));
 671
 672     pipeline_->Start(
 673         demuxer_.get(), CreateRenderer(),
 674         base::Bind(&PipelineIntegrationTest::OnEnded, base::Unretained(this)),
 675         base::Bind(&PipelineIntegrationTest::OnError, base::Unretained(this)),
 676         base::Bind(&PipelineIntegrationTest::OnStatusCallback,
 677                    base::Unretained(this)),
 678         base::Bind(&PipelineIntegrationTest::OnMetadata,
 679                    base::Unretained(this)),
 680         base::Bind(&PipelineIntegrationTest::OnBufferingStateChanged,
 681                    base::Unretained(this)),
 682         base::Bind(&PipelineIntegrationTest::OnVideoFramePaint,
 683                    base::Unretained(this)),
 684         base::Closure(), base::Bind(&PipelineIntegrationTest::OnAddTextTrack,
 685                                     base::Unretained(this)));
 686
 687     source->set_encrypted_media_init_data_cb(
 688         base::Bind(&FakeEncryptedMedia::OnEncryptedMediaInitData,
 689                    base::Unretained(encrypted_media)));
 690
 691     message_loop_.Run();
 692     EXPECT_EQ(PIPELINE_OK, pipeline_status_);
 693   }
 694
 695   // Verifies that seeking works properly for ChunkDemuxer when the
 696   // seek happens while there is a pending read on the ChunkDemuxer
 697   // and no data is available.
 698   bool TestSeekDuringRead(const std::string& filename,
 699                           const std::string& mimetype,
 700                           int initial_append_size,
 701                           base::TimeDelta start_seek_time,
 702                           base::TimeDelta seek_time,
 703                           int seek_file_position,
 704                           int seek_append_size) {
 705     MockMediaSource source(filename, mimetype, initial_append_size);
 706     StartPipelineWithMediaSource(&source);
 707
 708     if (pipeline_status_ != PIPELINE_OK)
 709       return false;
 710
 711     Play();
 712     if (!WaitUntilCurrentTimeIsAfter(start_seek_time))
 713       return false;
 714
 715     source.Seek(seek_time, seek_file_position, seek_append_size);
 716     if (!Seek(seek_time))
 717       return false;
 718
 719     source.EndOfStream();
 720
 721     source.Abort();
 722     Stop();
 723     return true;
 724   }
 725 };
 726
 727 TEST_F(PipelineIntegrationTest, BasicPlayback) {
 728   ASSERT_EQ(PIPELINE_OK, Start("bear-320x240.webm"));
 729
 730   Play();
 731
 732   ASSERT_TRUE(WaitUntilOnEnded());
 733 }
 734
 735 TEST_F(PipelineIntegrationTest, BasicPlaybackOpusOgg) {
 736   ASSERT_EQ(PIPELINE_OK, Start("bear-opus.ogg"));
 737
 738   Play();
 739
 740   ASSERT_TRUE(WaitUntilOnEnded());
 741 }
 742
 743 TEST_F(PipelineIntegrationTest, BasicPlaybackHashed) {
 744   ASSERT_EQ(PIPELINE_OK, Start("bear-320x240.webm", kHashed));
 745
 746   Play();
 747
 748   ASSERT_TRUE(WaitUntilOnEnded());
 749
 750   EXPECT_HASH_EQ("f0be120a90a811506777c99a2cdf7cc1", GetVideoHash());
 751   EXPECT_HASH_EQ("-3.59,-2.06,-0.43,2.15,0.77,-0.95,", GetAudioHash());
 752   EXPECT_TRUE(demuxer_->GetTimelineOffset().is_null());
 753 }
 754
 755 TEST_F(PipelineIntegrationTest, BasicPlaybackLive) {
 756   ASSERT_EQ(PIPELINE_OK, Start("bear-320x240-live.webm", kHashed));
 757
 758   Play();
 759
 760   ASSERT_TRUE(WaitUntilOnEnded());
 761
 762   EXPECT_HASH_EQ("f0be120a90a811506777c99a2cdf7cc1", GetVideoHash());
 763   EXPECT_HASH_EQ("-3.59,-2.06,-0.43,2.15,0.77,-0.95,", GetAudioHash());
 764
 765   // TODO: Fix FFmpeg code to return higher resolution time values so
 766   // we don't have to truncate our expectations here.
 767   EXPECT_EQ(TruncateToFFmpegTimeResolution(kLiveTimelineOffset()),
 768             demuxer_->GetTimelineOffset());
 769 }
 770
 771 TEST_F(PipelineIntegrationTest, F32PlaybackHashed) {
 772   ASSERT_EQ(PIPELINE_OK, Start("sfx_f32le.wav", kHashed));
 773   Play();
 774   ASSERT_TRUE(WaitUntilOnEnded());
 775   EXPECT_HASH_EQ(std::string(kNullVideoHash), GetVideoHash());
 776   EXPECT_HASH_EQ("3.03,2.86,2.99,3.31,3.57,4.06,", GetAudioHash());
 777 }
 778
 779 #if !defined(DISABLE_EME_TESTS)
 780 TEST_F(PipelineIntegrationTest, BasicPlaybackEncrypted) {
 781   FakeEncryptedMedia encrypted_media(new KeyProvidingApp());
 782   set_encrypted_media_init_data_cb(
 783       base::Bind(&FakeEncryptedMedia::OnEncryptedMediaInitData,
 784                  base::Unretained(&encrypted_media)));
 785
 786   ASSERT_EQ(PIPELINE_OK, Start("bear-320x240-av_enc-av.webm",
 787                                encrypted_media.GetCdmContext()));
 788
 789   Play();
 790
 791   ASSERT_TRUE(WaitUntilOnEnded());
 792   Stop();
 793 }
 794 #endif  // !defined(DISABLE_EME_TESTS)
 795
 796 TEST_F(PipelineIntegrationTest, BasicPlayback_MediaSource) {
 797   MockMediaSource source("bear-320x240.webm", kWebM, 219229);
 798   StartPipelineWithMediaSource(&source);
 799   source.EndOfStream();
 800
 801   EXPECT_EQ(1u, pipeline_->GetBufferedTimeRanges().size());
 802   EXPECT_EQ(0, pipeline_->GetBufferedTimeRanges().start(0).InMilliseconds());
 803   EXPECT_EQ(k320WebMFileDurationMs,
 804             pipeline_->GetBufferedTimeRanges().end(0).InMilliseconds());
 805
 806   Play();
 807
 808   ASSERT_TRUE(WaitUntilOnEnded());
 809
 810   EXPECT_TRUE(demuxer_->GetTimelineOffset().is_null());
 811   source.Abort();
 812   Stop();
 813 }
 814
 815 TEST_F(PipelineIntegrationTest, BasicPlayback_MediaSource_Live) {
 816   MockMediaSource source("bear-320x240-live.webm", kWebM, 219221);
 817   StartPipelineWithMediaSource(&source);
 818   source.EndOfStream();
 819
 820   EXPECT_EQ(1u, pipeline_->GetBufferedTimeRanges().size());
 821   EXPECT_EQ(0, pipeline_->GetBufferedTimeRanges().start(0).InMilliseconds());
 822   EXPECT_EQ(k320WebMFileDurationMs,
 823             pipeline_->GetBufferedTimeRanges().end(0).InMilliseconds());
 824
 825   Play();
 826
 827   ASSERT_TRUE(WaitUntilOnEnded());
 828
 829   EXPECT_EQ(kLiveTimelineOffset(),
 830             demuxer_->GetTimelineOffset());
 831   source.Abort();
 832   Stop();
 833 }
 834
 835 TEST_F(PipelineIntegrationTest, BasicPlayback_MediaSource_VP9_WebM) {
 836   MockMediaSource source("bear-vp9.webm", kWebMVP9, 67504);
 837   StartPipelineWithMediaSource(&source);
 838   source.EndOfStream();
 839
 840   EXPECT_EQ(1u, pipeline_->GetBufferedTimeRanges().size());
 841   EXPECT_EQ(0, pipeline_->GetBufferedTimeRanges().start(0).InMilliseconds());
 842   EXPECT_EQ(kVP9WebMFileDurationMs,
 843             pipeline_->GetBufferedTimeRanges().end(0).InMilliseconds());
 844
 845   Play();
 846
 847   ASSERT_TRUE(WaitUntilOnEnded());
 848   source.Abort();
 849   Stop();
 850 }
 851
 852 TEST_F(PipelineIntegrationTest, BasicPlayback_MediaSource_VP8A_WebM) {
 853   MockMediaSource source("bear-vp8a.webm", kVideoOnlyWebM, kAppendWholeFile);
 854   StartPipelineWithMediaSource(&source);
 855   source.EndOfStream();
 856
 857   EXPECT_EQ(1u, pipeline_->GetBufferedTimeRanges().size());
 858   EXPECT_EQ(0, pipeline_->GetBufferedTimeRanges().start(0).InMilliseconds());
 859   EXPECT_EQ(kVP8AWebMFileDurationMs,
 860             pipeline_->GetBufferedTimeRanges().end(0).InMilliseconds());
 861
 862   Play();
 863
 864   ASSERT_TRUE(WaitUntilOnEnded());
 865   source.Abort();
 866   Stop();
 867 }
 868
 869 TEST_F(PipelineIntegrationTest, BasicPlayback_MediaSource_Opus_WebM) {
 870   MockMediaSource source("bear-opus-end-trimming.webm", kOpusAudioOnlyWebM,
 871                          kAppendWholeFile);
 872   StartPipelineWithMediaSource(&source);
 873   source.EndOfStream();
 874
 875   EXPECT_EQ(1u, pipeline_->GetBufferedTimeRanges().size());
 876   EXPECT_EQ(0, pipeline_->GetBufferedTimeRanges().start(0).InMilliseconds());
 877   EXPECT_EQ(kOpusEndTrimmingWebMFileDurationMs,
 878             pipeline_->GetBufferedTimeRanges().end(0).InMilliseconds());
 879   Play();
 880
 881   ASSERT_TRUE(WaitUntilOnEnded());
 882   source.Abort();
 883   Stop();
 884 }
 885
 886 // Flaky. http://crbug.com/304776
 887 TEST_F(PipelineIntegrationTest, DISABLED_MediaSource_Opus_Seeking_WebM) {
 888   MockMediaSource source("bear-opus-end-trimming.webm", kOpusAudioOnlyWebM,
 889                          kAppendWholeFile);
 890   StartHashedPipelineWithMediaSource(&source);
 891
 892   EXPECT_EQ(1u, pipeline_->GetBufferedTimeRanges().size());
 893   EXPECT_EQ(0, pipeline_->GetBufferedTimeRanges().start(0).InMilliseconds());
 894   EXPECT_EQ(kOpusEndTrimmingWebMFileDurationMs,
 895             pipeline_->GetBufferedTimeRanges().end(0).InMilliseconds());
 896
 897   base::TimeDelta start_seek_time = base::TimeDelta::FromMilliseconds(1000);
 898   base::TimeDelta seek_time = base::TimeDelta::FromMilliseconds(2000);
 899
 900   Play();
 901   ASSERT_TRUE(WaitUntilCurrentTimeIsAfter(start_seek_time));
 902   source.Seek(seek_time, 0x1D5, 34017);
 903   source.EndOfStream();
 904   ASSERT_TRUE(Seek(seek_time));
 905
 906   ASSERT_TRUE(WaitUntilOnEnded());
 907
 908   EXPECT_HASH_EQ("0.76,0.20,-0.82,-0.58,-1.29,-0.29,", GetAudioHash());
 909
 910   source.Abort();
 911   Stop();
 912 }
 913
 914 TEST_F(PipelineIntegrationTest, MediaSource_ConfigChange_WebM) {
 915   MockMediaSource source("bear-320x240-16x9-aspect.webm", kWebM,
 916                          kAppendWholeFile);
 917   StartPipelineWithMediaSource(&source);
 918
 919   scoped_refptr<DecoderBuffer> second_file =
 920       ReadTestDataFile("bear-640x360.webm");
 921
 922   source.AppendAtTime(base::TimeDelta::FromSeconds(kAppendTimeSec),
 923                       second_file->data(), second_file->data_size());
 924
 925   source.EndOfStream();
 926
 927   EXPECT_EQ(1u, pipeline_->GetBufferedTimeRanges().size());
 928   EXPECT_EQ(0, pipeline_->GetBufferedTimeRanges().start(0).InMilliseconds());
 929   EXPECT_EQ(kAppendTimeMs + k640WebMFileDurationMs,
 930             pipeline_->GetBufferedTimeRanges().end(0).InMilliseconds());
 931
 932   Play();
 933
 934   EXPECT_TRUE(WaitUntilOnEnded());
 935   source.Abort();
 936   Stop();
 937 }
 938
 939 #if !defined(DISABLE_EME_TESTS)
 940 TEST_F(PipelineIntegrationTest, MediaSource_ConfigChange_Encrypted_WebM) {
 941   MockMediaSource source("bear-320x240-16x9-aspect-av_enc-av.webm", kWebM,
 942                          kAppendWholeFile);
 943   FakeEncryptedMedia encrypted_media(new KeyProvidingApp());
 944   StartPipelineWithEncryptedMedia(&source, &encrypted_media);
 945
 946   scoped_refptr<DecoderBuffer> second_file =
 947       ReadTestDataFile("bear-640x360-av_enc-av.webm");
 948
 949   source.AppendAtTime(base::TimeDelta::FromSeconds(kAppendTimeSec),
 950                       second_file->data(), second_file->data_size());
 951
 952   source.EndOfStream();
 953
 954   EXPECT_EQ(1u, pipeline_->GetBufferedTimeRanges().size());
 955   EXPECT_EQ(0, pipeline_->GetBufferedTimeRanges().start(0).InMilliseconds());
 956   EXPECT_EQ(kAppendTimeMs + k640WebMFileDurationMs,
 957             pipeline_->GetBufferedTimeRanges().end(0).InMilliseconds());
 958
 959   Play();
 960
 961   EXPECT_TRUE(WaitUntilOnEnded());
 962   source.Abort();
 963   Stop();
 964 }
 965
 966 // Config changes from encrypted to clear are not currently supported.
 967 TEST_F(PipelineIntegrationTest,
 968        MediaSource_ConfigChange_ClearThenEncrypted_WebM) {
 969   MockMediaSource source("bear-320x240-16x9-aspect.webm", kWebM,
 970                          kAppendWholeFile);
 971   FakeEncryptedMedia encrypted_media(new KeyProvidingApp());
 972   StartPipelineWithEncryptedMedia(&source, &encrypted_media);
 973
 974   scoped_refptr<DecoderBuffer> second_file =
 975       ReadTestDataFile("bear-640x360-av_enc-av.webm");
 976
 977   source.AppendAtTime(base::TimeDelta::FromSeconds(kAppendTimeSec),
 978                       second_file->data(), second_file->data_size());
 979
 980   source.EndOfStream();
 981
 982   message_loop_.Run();
 983   EXPECT_EQ(PIPELINE_ERROR_DECODE, pipeline_status_);
 984
 985   EXPECT_EQ(1u, pipeline_->GetBufferedTimeRanges().size());
 986   EXPECT_EQ(0, pipeline_->GetBufferedTimeRanges().start(0).InMilliseconds());
 987   // The second video was not added, so its time has not been added.
 988   EXPECT_EQ(k320WebMFileDurationMs,
 989             pipeline_->GetBufferedTimeRanges().end(0).InMilliseconds());
 990
 991   Play();
 992
 993   EXPECT_EQ(PIPELINE_ERROR_DECODE, WaitUntilEndedOrError());
 994   source.Abort();
 995 }
 996
 997 // Config changes from clear to encrypted are not currently supported.
 998 TEST_F(PipelineIntegrationTest,
 999        MediaSource_ConfigChange_EncryptedThenClear_WebM) {
1000   MockMediaSource source("bear-320x240-16x9-aspect-av_enc-av.webm", kWebM,
1001                          kAppendWholeFile);
1002   FakeEncryptedMedia encrypted_media(new KeyProvidingApp());
1003   StartPipelineWithEncryptedMedia(&source, &encrypted_media);
1004
1005   scoped_refptr<DecoderBuffer> second_file =
1006       ReadTestDataFile("bear-640x360.webm");
1007
1008   source.AppendAtTime(base::TimeDelta::FromSeconds(kAppendTimeSec),
1009                       second_file->data(), second_file->data_size());
1010
1011   source.EndOfStream();
1012
1013   EXPECT_EQ(1u, pipeline_->GetBufferedTimeRanges().size());
1014   EXPECT_EQ(0, pipeline_->GetBufferedTimeRanges().start(0).InMilliseconds());
1015   // The second video was not added, so its time has not been added.
1016   EXPECT_EQ(k320WebMFileDurationMs,
1017             pipeline_->GetBufferedTimeRanges().end(0).InMilliseconds());
1018
1019   Play();
1020
1021   EXPECT_EQ(PIPELINE_ERROR_DECODE, WaitUntilEndedOrError());
1022   source.Abort();
1023 }
1024 #endif  // !defined(DISABLE_EME_TESTS)
1025
1026 #if defined(USE_PROPRIETARY_CODECS)
1027 TEST_F(PipelineIntegrationTest, MediaSource_ADTS) {
1028   MockMediaSource source("sfx.adts", kADTS, kAppendWholeFile);
1029   StartPipelineWithMediaSource(&source);
1030   source.EndOfStream();
1031
1032   EXPECT_EQ(1u, pipeline_->GetBufferedTimeRanges().size());
1033   EXPECT_EQ(0, pipeline_->GetBufferedTimeRanges().start(0).InMilliseconds());
1034   EXPECT_EQ(325, pipeline_->GetBufferedTimeRanges().end(0).InMilliseconds());
1035
1036   Play();
1037
1038   EXPECT_TRUE(WaitUntilOnEnded());
1039 }
1040
1041 TEST_F(PipelineIntegrationTest, MediaSource_ADTS_TimestampOffset) {
1042   MockMediaSource source("sfx.adts", kADTS, kAppendWholeFile);
1043   StartHashedPipelineWithMediaSource(&source);
1044   EXPECT_EQ(325, source.last_timestamp_offset().InMilliseconds());
1045
1046   // Trim off multiple frames off the beginning of the segment which will cause
1047   // the first decoded frame to be incorrect if preroll isn't implemented.
1048   const base::TimeDelta adts_preroll_duration =
1049       base::TimeDelta::FromSecondsD(2.5 * 1024 / 44100);
1050   const base::TimeDelta append_time =
1051       source.last_timestamp_offset() - adts_preroll_duration;
1052
1053   scoped_refptr<DecoderBuffer> second_file = ReadTestDataFile("sfx.adts");
1054   source.AppendAtTimeWithWindow(append_time,
1055                                 append_time + adts_preroll_duration,
1056                                 kInfiniteDuration(),
1057                                 second_file->data(),
1058                                 second_file->data_size());
1059   source.EndOfStream();
1060
1061   EXPECT_EQ(592, source.last_timestamp_offset().InMilliseconds());
1062   EXPECT_EQ(1u, pipeline_->GetBufferedTimeRanges().size());
1063   EXPECT_EQ(0, pipeline_->GetBufferedTimeRanges().start(0).InMilliseconds());
1064   EXPECT_EQ(592, pipeline_->GetBufferedTimeRanges().end(0).InMilliseconds());
1065
1066   Play();
1067
1068   EXPECT_TRUE(WaitUntilOnEnded());
1069
1070   // Verify preroll is stripped.
1071   EXPECT_HASH_EQ("-0.06,0.97,-0.90,-0.70,-0.53,-0.34,", GetAudioHash());
1072 }
1073
1074 TEST_F(PipelineIntegrationTest, BasicPlaybackHashed_MP3) {
1075   ASSERT_EQ(PIPELINE_OK, Start("sfx.mp3", kHashed));
1076
1077   Play();
1078
1079   ASSERT_TRUE(WaitUntilOnEnded());
1080
1081   // Verify codec delay and preroll are stripped.
1082   EXPECT_HASH_EQ("1.30,2.72,4.56,5.08,3.74,2.03,", GetAudioHash());
1083 }
1084
1085 TEST_F(PipelineIntegrationTest, MediaSource_MP3) {
1086   MockMediaSource source("sfx.mp3", kMP3, kAppendWholeFile);
1087   StartHashedPipelineWithMediaSource(&source);
1088   source.EndOfStream();
1089
1090   EXPECT_EQ(1u, pipeline_->GetBufferedTimeRanges().size());
1091   EXPECT_EQ(0, pipeline_->GetBufferedTimeRanges().start(0).InMilliseconds());
1092   EXPECT_EQ(313, pipeline_->GetBufferedTimeRanges().end(0).InMilliseconds());
1093
1094   Play();
1095
1096   EXPECT_TRUE(WaitUntilOnEnded());
1097
1098   // Verify that codec delay was stripped.
1099   EXPECT_HASH_EQ("1.01,2.71,4.18,4.32,3.04,1.12,", GetAudioHash());
1100 }
1101
1102 TEST_F(PipelineIntegrationTest, MediaSource_MP3_TimestampOffset) {
1103   MockMediaSource source("sfx.mp3", kMP3, kAppendWholeFile);
1104   StartPipelineWithMediaSource(&source);
1105   EXPECT_EQ(313, source.last_timestamp_offset().InMilliseconds());
1106
1107   // There are 576 silent frames at the start of this mp3.  The second append
1108   // should trim them off.
1109   const base::TimeDelta mp3_preroll_duration =
1110       base::TimeDelta::FromSecondsD(576.0 / 44100);
1111   const base::TimeDelta append_time =
1112       source.last_timestamp_offset() - mp3_preroll_duration;
1113
1114   scoped_refptr<DecoderBuffer> second_file = ReadTestDataFile("sfx.mp3");
1115   source.AppendAtTimeWithWindow(append_time,
1116                                 append_time + mp3_preroll_duration,
1117                                 kInfiniteDuration(),
1118                                 second_file->data(),
1119                                 second_file->data_size());
1120   source.EndOfStream();
1121
1122   EXPECT_EQ(613, source.last_timestamp_offset().InMilliseconds());
1123   EXPECT_EQ(1u, pipeline_->GetBufferedTimeRanges().size());
1124   EXPECT_EQ(0, pipeline_->GetBufferedTimeRanges().start(0).InMilliseconds());
1125   EXPECT_EQ(613, pipeline_->GetBufferedTimeRanges().end(0).InMilliseconds());
1126
1127   Play();
1128
1129   EXPECT_TRUE(WaitUntilOnEnded());
1130 }
1131
1132 TEST_F(PipelineIntegrationTest, MediaSource_MP3_Icecast) {
1133   MockMediaSource source("icy_sfx.mp3", kMP3, kAppendWholeFile);
1134   StartPipelineWithMediaSource(&source);
1135   source.EndOfStream();
1136
1137   Play();
1138
1139   EXPECT_TRUE(WaitUntilOnEnded());
1140 }
1141
1142 TEST_F(PipelineIntegrationTest, MediaSource_ConfigChange_MP4) {
1143   MockMediaSource source("bear-640x360-av_frag.mp4", kMP4, kAppendWholeFile);
1144   StartPipelineWithMediaSource(&source);
1145
1146   scoped_refptr<DecoderBuffer> second_file =
1147       ReadTestDataFile("bear-1280x720-av_frag.mp4");
1148
1149   source.AppendAtTime(base::TimeDelta::FromSeconds(kAppendTimeSec),
1150                       second_file->data(), second_file->data_size());
1151
1152   source.EndOfStream();
1153
1154   EXPECT_EQ(1u, pipeline_->GetBufferedTimeRanges().size());
1155   EXPECT_EQ(0, pipeline_->GetBufferedTimeRanges().start(0).InMilliseconds());
1156   EXPECT_EQ(kAppendTimeMs + k1280IsoFileDurationMs,
1157             pipeline_->GetBufferedTimeRanges().end(0).InMilliseconds());
1158
1159   Play();
1160
1161   EXPECT_TRUE(WaitUntilOnEnded());
1162   source.Abort();
1163   Stop();
1164 }
1165
1166 #if !defined(DISABLE_EME_TESTS)
1167 TEST_F(PipelineIntegrationTest,
1168        MediaSource_ConfigChange_Encrypted_MP4_CENC_VideoOnly) {
1169   MockMediaSource source("bear-640x360-v_frag-cenc.mp4", kMP4Video,
1170                          kAppendWholeFile);
1171   FakeEncryptedMedia encrypted_media(new KeyProvidingApp());
1172   StartPipelineWithEncryptedMedia(&source, &encrypted_media);
1173
1174   scoped_refptr<DecoderBuffer> second_file =
1175       ReadTestDataFile("bear-1280x720-v_frag-cenc.mp4");
1176
1177   source.AppendAtTime(base::TimeDelta::FromSeconds(kAppendTimeSec),
1178                       second_file->data(), second_file->data_size());
1179
1180   source.EndOfStream();
1181
1182   EXPECT_EQ(1u, pipeline_->GetBufferedTimeRanges().size());
1183   EXPECT_EQ(0, pipeline_->GetBufferedTimeRanges().start(0).InMilliseconds());
1184   EXPECT_EQ(kAppendTimeMs + k1280IsoFileDurationMs,
1185             pipeline_->GetBufferedTimeRanges().end(0).InMilliseconds());
1186
1187   Play();
1188
1189   EXPECT_TRUE(WaitUntilOnEnded());
1190   source.Abort();
1191   Stop();
1192 }
1193
1194 TEST_F(PipelineIntegrationTest,
1195        MediaSource_ConfigChange_Encrypted_MP4_CENC_KeyRotation_VideoOnly) {
1196   MockMediaSource source("bear-640x360-v_frag-cenc-key_rotation.mp4", kMP4Video,
1197                          kAppendWholeFile);
1198   FakeEncryptedMedia encrypted_media(new RotatingKeyProvidingApp());
1199   StartPipelineWithEncryptedMedia(&source, &encrypted_media);
1200
1201   scoped_refptr<DecoderBuffer> second_file =
1202       ReadTestDataFile("bear-1280x720-v_frag-cenc-key_rotation.mp4");
1203
1204   source.AppendAtTime(base::TimeDelta::FromSeconds(kAppendTimeSec),
1205                       second_file->data(), second_file->data_size());
1206
1207   source.EndOfStream();
1208
1209   EXPECT_EQ(1u, pipeline_->GetBufferedTimeRanges().size());
1210   EXPECT_EQ(0, pipeline_->GetBufferedTimeRanges().start(0).InMilliseconds());
1211   EXPECT_EQ(kAppendTimeMs + k1280IsoFileDurationMs,
1212             pipeline_->GetBufferedTimeRanges().end(0).InMilliseconds());
1213
1214   Play();
1215
1216   EXPECT_TRUE(WaitUntilOnEnded());
1217   source.Abort();
1218   Stop();
1219 }
1220
1221 // Config changes from clear to encrypted are not currently supported.
1222 // TODO(ddorwin): Figure out why this CHECKs in AppendAtTime().
1223 TEST_F(PipelineIntegrationTest,
1224        DISABLED_MediaSource_ConfigChange_ClearThenEncrypted_MP4_CENC) {
1225   MockMediaSource source("bear-640x360-av_frag.mp4", kMP4Video,
1226                          kAppendWholeFile);
1227   FakeEncryptedMedia encrypted_media(new KeyProvidingApp());
1228   StartPipelineWithEncryptedMedia(&source, &encrypted_media);
1229
1230   scoped_refptr<DecoderBuffer> second_file =
1231       ReadTestDataFile("bear-1280x720-v_frag-cenc.mp4");
1232
1233   source.AppendAtTime(base::TimeDelta::FromSeconds(kAppendTimeSec),
1234                       second_file->data(), second_file->data_size());
1235
1236   source.EndOfStream();
1237
1238   message_loop_.Run();
1239   EXPECT_EQ(PIPELINE_ERROR_DECODE, pipeline_status_);
1240
1241   EXPECT_EQ(1u, pipeline_->GetBufferedTimeRanges().size());
1242   EXPECT_EQ(0, pipeline_->GetBufferedTimeRanges().start(0).InMilliseconds());
1243   // The second video was not added, so its time has not been added.
1244   EXPECT_EQ(k640IsoFileDurationMs,
1245             pipeline_->GetBufferedTimeRanges().end(0).InMilliseconds());
1246
1247   Play();
1248
1249   EXPECT_EQ(PIPELINE_ERROR_DECODE, WaitUntilEndedOrError());
1250   source.Abort();
1251 }
1252
1253 // Config changes from encrypted to clear are not currently supported.
1254 TEST_F(PipelineIntegrationTest,
1255        MediaSource_ConfigChange_EncryptedThenClear_MP4_CENC) {
1256   MockMediaSource source("bear-640x360-v_frag-cenc.mp4", kMP4Video,
1257                          kAppendWholeFile);
1258   FakeEncryptedMedia encrypted_media(new KeyProvidingApp());
1259   StartPipelineWithEncryptedMedia(&source, &encrypted_media);
1260
1261   scoped_refptr<DecoderBuffer> second_file =
1262       ReadTestDataFile("bear-1280x720-av_frag.mp4");
1263
1264   source.AppendAtTime(base::TimeDelta::FromSeconds(kAppendTimeSec),
1265                       second_file->data(), second_file->data_size());
1266
1267   source.EndOfStream();
1268
1269   EXPECT_EQ(1u, pipeline_->GetBufferedTimeRanges().size());
1270   EXPECT_EQ(0, pipeline_->GetBufferedTimeRanges().start(0).InMilliseconds());
1271   // The second video was not added, so its time has not been added.
1272   EXPECT_EQ(k640IsoCencFileDurationMs,
1273             pipeline_->GetBufferedTimeRanges().end(0).InMilliseconds());
1274
1275   Play();
1276
1277   EXPECT_EQ(PIPELINE_ERROR_DECODE, WaitUntilEndedOrError());
1278   source.Abort();
1279 }
1280 #endif  // !defined(DISABLE_EME_TESTS)
1281
1282 // Verify files which change configuration midstream fail gracefully.
1283 TEST_F(PipelineIntegrationTest, MidStreamConfigChangesFail) {
1284   ASSERT_EQ(PIPELINE_OK, Start("midstream_config_change.mp3"));
1285   Play();
1286   ASSERT_EQ(WaitUntilEndedOrError(), PIPELINE_ERROR_DECODE);
1287 }
1288
1289 #endif
1290
1291 TEST_F(PipelineIntegrationTest, BasicPlayback_16x9AspectRatio) {
1292   ASSERT_EQ(PIPELINE_OK, Start("bear-320x240-16x9-aspect.webm"));
1293   Play();
1294   ASSERT_TRUE(WaitUntilOnEnded());
1295 }
1296
1297 #if !defined(DISABLE_EME_TESTS)
1298 TEST_F(PipelineIntegrationTest, EncryptedPlayback_WebM) {
1299   MockMediaSource source("bear-320x240-av_enc-av.webm", kWebM, 219816);
1300   FakeEncryptedMedia encrypted_media(new KeyProvidingApp());
1301   StartPipelineWithEncryptedMedia(&source, &encrypted_media);
1302
1303   source.EndOfStream();
1304   ASSERT_EQ(PIPELINE_OK, pipeline_status_);
1305
1306   Play();
1307
1308   ASSERT_TRUE(WaitUntilOnEnded());
1309   source.Abort();
1310   Stop();
1311 }
1312
1313 TEST_F(PipelineIntegrationTest, EncryptedPlayback_ClearStart_WebM) {
1314   MockMediaSource source("bear-320x240-av_enc-av_clear-1s.webm", kWebM,
1315                          kAppendWholeFile);
1316   FakeEncryptedMedia encrypted_media(new KeyProvidingApp());
1317   StartPipelineWithEncryptedMedia(&source, &encrypted_media);
1318
1319   source.EndOfStream();
1320   ASSERT_EQ(PIPELINE_OK, pipeline_status_);
1321
1322   Play();
1323
1324   ASSERT_TRUE(WaitUntilOnEnded());
1325   source.Abort();
1326   Stop();
1327 }
1328
1329 TEST_F(PipelineIntegrationTest, EncryptedPlayback_NoEncryptedFrames_WebM) {
1330   MockMediaSource source("bear-320x240-av_enc-av_clear-all.webm", kWebM,
1331                          kAppendWholeFile);
1332   FakeEncryptedMedia encrypted_media(new NoResponseApp());
1333   StartPipelineWithEncryptedMedia(&source, &encrypted_media);
1334
1335   source.EndOfStream();
1336   ASSERT_EQ(PIPELINE_OK, pipeline_status_);
1337
1338   Play();
1339
1340   ASSERT_TRUE(WaitUntilOnEnded());
1341   source.Abort();
1342   Stop();
1343 }
1344 #endif  // !defined(DISABLE_EME_TESTS)
1345
1346 #if defined(USE_PROPRIETARY_CODECS)
1347 #if !defined(DISABLE_EME_TESTS)
1348 TEST_F(PipelineIntegrationTest, EncryptedPlayback_MP4_CENC_VideoOnly) {
1349   MockMediaSource source("bear-1280x720-v_frag-cenc.mp4", kMP4Video,
1350                          kAppendWholeFile);
1351   FakeEncryptedMedia encrypted_media(new KeyProvidingApp());
1352   StartPipelineWithEncryptedMedia(&source, &encrypted_media);
1353
1354   source.EndOfStream();
1355   ASSERT_EQ(PIPELINE_OK, pipeline_status_);
1356
1357   Play();
1358
1359   ASSERT_TRUE(WaitUntilOnEnded());
1360   source.Abort();
1361   Stop();
1362 }
1363
1364 TEST_F(PipelineIntegrationTest, EncryptedPlayback_MP4_CENC_AudioOnly) {
1365   MockMediaSource source("bear-1280x720-a_frag-cenc.mp4", kMP4Audio,
1366                          kAppendWholeFile);
1367   FakeEncryptedMedia encrypted_media(new KeyProvidingApp());
1368   StartPipelineWithEncryptedMedia(&source, &encrypted_media);
1369
1370   source.EndOfStream();
1371   ASSERT_EQ(PIPELINE_OK, pipeline_status_);
1372
1373   Play();
1374
1375   ASSERT_TRUE(WaitUntilOnEnded());
1376   source.Abort();
1377   Stop();
1378 }
1379
1380 TEST_F(PipelineIntegrationTest,
1381        EncryptedPlayback_NoEncryptedFrames_MP4_CENC_VideoOnly) {
1382   MockMediaSource source("bear-1280x720-v_frag-cenc_clear-all.mp4", kMP4Video,
1383                          kAppendWholeFile);
1384   FakeEncryptedMedia encrypted_media(new NoResponseApp());
1385   StartPipelineWithEncryptedMedia(&source, &encrypted_media);
1386
1387   source.EndOfStream();
1388   ASSERT_EQ(PIPELINE_OK, pipeline_status_);
1389
1390   Play();
1391
1392   ASSERT_TRUE(WaitUntilOnEnded());
1393   source.Abort();
1394   Stop();
1395 }
1396
1397 TEST_F(PipelineIntegrationTest,
1398        EncryptedPlayback_NoEncryptedFrames_MP4_CENC_AudioOnly) {
1399   MockMediaSource source("bear-1280x720-a_frag-cenc_clear-all.mp4", kMP4Audio,
1400                          kAppendWholeFile);
1401   FakeEncryptedMedia encrypted_media(new NoResponseApp());
1402   StartPipelineWithEncryptedMedia(&source, &encrypted_media);
1403
1404   source.EndOfStream();
1405   ASSERT_EQ(PIPELINE_OK, pipeline_status_);
1406
1407   Play();
1408
1409   ASSERT_TRUE(WaitUntilOnEnded());
1410   source.Abort();
1411   Stop();
1412 }
1413
1414 TEST_F(PipelineIntegrationTest, EncryptedPlayback_MP4_CENC_KeyRotation_Video) {
1415   MockMediaSource source("bear-1280x720-v_frag-cenc-key_rotation.mp4",
1416                          kMP4Video, kAppendWholeFile);
1417   FakeEncryptedMedia encrypted_media(new RotatingKeyProvidingApp());
1418   StartPipelineWithEncryptedMedia(&source, &encrypted_media);
1419
1420   source.EndOfStream();
1421   ASSERT_EQ(PIPELINE_OK, pipeline_status_);
1422
1423   Play();
1424
1425   ASSERT_TRUE(WaitUntilOnEnded());
1426   source.Abort();
1427   Stop();
1428 }
1429
1430 TEST_F(PipelineIntegrationTest, EncryptedPlayback_MP4_CENC_KeyRotation_Audio) {
1431   MockMediaSource source("bear-1280x720-a_frag-cenc-key_rotation.mp4",
1432                          kMP4Audio, kAppendWholeFile);
1433   FakeEncryptedMedia encrypted_media(new RotatingKeyProvidingApp());
1434   StartPipelineWithEncryptedMedia(&source, &encrypted_media);
1435
1436   source.EndOfStream();
1437   ASSERT_EQ(PIPELINE_OK, pipeline_status_);
1438
1439   Play();
1440
1441   ASSERT_TRUE(WaitUntilOnEnded());
1442   source.Abort();
1443   Stop();
1444 }
1445 #endif  // !defined(DISABLE_EME_TESTS)
1446
1447 TEST_F(PipelineIntegrationTest, BasicPlayback_MediaSource_VideoOnly_MP4_AVC3) {
1448   MockMediaSource source("bear-1280x720-v_frag-avc3.mp4", kMP4VideoAVC3,
1449                          kAppendWholeFile);
1450   StartPipelineWithMediaSource(&source);
1451   source.EndOfStream();
1452
1453   EXPECT_EQ(1u, pipeline_->GetBufferedTimeRanges().size());
1454   EXPECT_EQ(0, pipeline_->GetBufferedTimeRanges().start(0).InMilliseconds());
1455   EXPECT_EQ(k1280IsoAVC3FileDurationMs,
1456             pipeline_->GetBufferedTimeRanges().end(0).InMilliseconds());
1457
1458   Play();
1459
1460   ASSERT_TRUE(WaitUntilOnEnded());
1461   source.Abort();
1462   Stop();
1463 }
1464 #endif  // defined(USE_PROPRIETARY_CODECS)
1465
1466 TEST_F(PipelineIntegrationTest, SeekWhilePaused) {
1467   ASSERT_EQ(PIPELINE_OK, Start("bear-320x240.webm"));
1468
1469   base::TimeDelta duration(pipeline_->GetMediaDuration());
1470   base::TimeDelta start_seek_time(duration / 4);
1471   base::TimeDelta seek_time(duration * 3 / 4);
1472
1473   Play();
1474   ASSERT_TRUE(WaitUntilCurrentTimeIsAfter(start_seek_time));
1475   Pause();
1476   ASSERT_TRUE(Seek(seek_time));
1477   EXPECT_EQ(seek_time, pipeline_->GetMediaTime());
1478   Play();
1479   ASSERT_TRUE(WaitUntilOnEnded());
1480
1481   // Make sure seeking after reaching the end works as expected.
1482   Pause();
1483   ASSERT_TRUE(Seek(seek_time));
1484   EXPECT_EQ(seek_time, pipeline_->GetMediaTime());
1485   Play();
1486   ASSERT_TRUE(WaitUntilOnEnded());
1487 }
1488
1489 TEST_F(PipelineIntegrationTest, SeekWhilePlaying) {
1490   ASSERT_EQ(PIPELINE_OK, Start("bear-320x240.webm"));
1491
1492   base::TimeDelta duration(pipeline_->GetMediaDuration());
1493   base::TimeDelta start_seek_time(duration / 4);
1494   base::TimeDelta seek_time(duration * 3 / 4);
1495
1496   Play();
1497   ASSERT_TRUE(WaitUntilCurrentTimeIsAfter(start_seek_time));
1498   ASSERT_TRUE(Seek(seek_time));
1499   EXPECT_GE(pipeline_->GetMediaTime(), seek_time);
1500   ASSERT_TRUE(WaitUntilOnEnded());
1501
1502   // Make sure seeking after reaching the end works as expected.
1503   ASSERT_TRUE(Seek(seek_time));
1504   EXPECT_GE(pipeline_->GetMediaTime(), seek_time);
1505   ASSERT_TRUE(WaitUntilOnEnded());
1506 }
1507
1508 #if defined(USE_PROPRIETARY_CODECS)
1509 TEST_F(PipelineIntegrationTest, Rotated_Metadata_0) {
1510   ASSERT_EQ(PIPELINE_OK, Start("bear_rotate_0.mp4"));
1511   ASSERT_EQ(VIDEO_ROTATION_0, metadata_.video_rotation);
1512 }
1513
1514 TEST_F(PipelineIntegrationTest, Rotated_Metadata_90) {
1515   ASSERT_EQ(PIPELINE_OK, Start("bear_rotate_90.mp4"));
1516   ASSERT_EQ(VIDEO_ROTATION_90, metadata_.video_rotation);
1517 }
1518
1519 TEST_F(PipelineIntegrationTest, Rotated_Metadata_180) {
1520   ASSERT_EQ(PIPELINE_OK, Start("bear_rotate_180.mp4"));
1521   ASSERT_EQ(VIDEO_ROTATION_180, metadata_.video_rotation);
1522 }
1523
1524 TEST_F(PipelineIntegrationTest, Rotated_Metadata_270) {
1525   ASSERT_EQ(PIPELINE_OK, Start("bear_rotate_270.mp4"));
1526   ASSERT_EQ(VIDEO_ROTATION_270, metadata_.video_rotation);
1527 }
1528 #endif
1529
1530 // Verify audio decoder & renderer can handle aborted demuxer reads.
1531 TEST_F(PipelineIntegrationTest, ChunkDemuxerAbortRead_AudioOnly) {
1532   ASSERT_TRUE(TestSeekDuringRead("bear-320x240-audio-only.webm", kAudioOnlyWebM,
1533                                  16384,
1534                                  base::TimeDelta::FromMilliseconds(464),
1535                                  base::TimeDelta::FromMilliseconds(617),
1536                                  0x10CA, 19730));
1537 }
1538
1539 // Verify video decoder & renderer can handle aborted demuxer reads.
1540 TEST_F(PipelineIntegrationTest, ChunkDemuxerAbortRead_VideoOnly) {
1541   ASSERT_TRUE(TestSeekDuringRead("bear-320x240-video-only.webm", kVideoOnlyWebM,
1542                                  32768,
1543                                  base::TimeDelta::FromMilliseconds(167),
1544                                  base::TimeDelta::FromMilliseconds(1668),
1545                                  0x1C896, 65536));
1546 }
1547
1548 // Verify that Opus audio in WebM containers can be played back.
1549 TEST_F(PipelineIntegrationTest, BasicPlayback_AudioOnly_Opus_WebM) {
1550   ASSERT_EQ(PIPELINE_OK, Start("bear-opus-end-trimming.webm"));
1551   Play();
1552   ASSERT_TRUE(WaitUntilOnEnded());
1553 }
1554
1555 // Verify that VP9 video in WebM containers can be played back.
1556 TEST_F(PipelineIntegrationTest, BasicPlayback_VideoOnly_VP9_WebM) {
1557   ASSERT_EQ(PIPELINE_OK, Start("bear-vp9.webm"));
1558   Play();
1559   ASSERT_TRUE(WaitUntilOnEnded());
1560 }
1561
1562 // Verify that VP9 video and Opus audio in the same WebM container can be played
1563 // back.
1564 TEST_F(PipelineIntegrationTest, BasicPlayback_VP9_Opus_WebM) {
1565   ASSERT_EQ(PIPELINE_OK, Start("bear-vp9-opus.webm"));
1566   Play();
1567   ASSERT_TRUE(WaitUntilOnEnded());
1568 }
1569
1570 // Verify that VP8 video with alpha channel can be played back.
1571 TEST_F(PipelineIntegrationTest, BasicPlayback_VP8A_WebM) {
1572   ASSERT_EQ(PIPELINE_OK, Start("bear-vp8a.webm"));
1573   Play();
1574   ASSERT_TRUE(WaitUntilOnEnded());
1575   EXPECT_VIDEO_FORMAT_EQ(last_video_frame_format_, VideoFrame::YV12A);
1576 }
1577
1578 // Verify that VP8A video with odd width/height can be played back.
1579 TEST_F(PipelineIntegrationTest, BasicPlayback_VP8A_Odd_WebM) {
1580   ASSERT_EQ(PIPELINE_OK, Start("bear-vp8a-odd-dimensions.webm"));
1581   Play();
1582   ASSERT_TRUE(WaitUntilOnEnded());
1583   EXPECT_VIDEO_FORMAT_EQ(last_video_frame_format_, VideoFrame::YV12A);
1584 }
1585
1586 // Verify that VP9 video with odd width/height can be played back.
1587 TEST_F(PipelineIntegrationTest, BasicPlayback_VP9_Odd_WebM) {
1588   ASSERT_EQ(PIPELINE_OK, Start("bear-vp9-odd-dimensions.webm"));
1589   Play();
1590   ASSERT_TRUE(WaitUntilOnEnded());
1591 }
1592
1593 #if !defined(DISABLE_TEXT_TRACK_TESTS)
1594 // Verify that VP8 video with inband text track can be played back.
1595 TEST_F(PipelineIntegrationTest, BasicPlayback_VP8_WebVTT_WebM) {
1596   EXPECT_CALL(*this, OnAddTextTrack(_, _));
1597   ASSERT_EQ(PIPELINE_OK, Start("bear-vp8-webvtt.webm"));
1598   Play();
1599   ASSERT_TRUE(WaitUntilOnEnded());
1600 }
1601 #endif  // !defined(DISABLE_TEXT_TRACK_TESTS)
1602
1603 // Verify that VP9 video with 4:4:4 subsampling can be played back.
1604 TEST_F(PipelineIntegrationTest, P444_VP9_WebM) {
1605   ASSERT_EQ(PIPELINE_OK, Start("bear-320x240-P444.webm"));
1606   Play();
1607   ASSERT_TRUE(WaitUntilOnEnded());
1608   EXPECT_VIDEO_FORMAT_EQ(last_video_frame_format_, VideoFrame::YV24);
1609 }
1610
1611 // Verify that videos with an odd frame size playback successfully.
1612 TEST_F(PipelineIntegrationTest, BasicPlayback_OddVideoSize) {
1613   ASSERT_EQ(PIPELINE_OK, Start("butterfly-853x480.webm"));
1614   Play();
1615   ASSERT_TRUE(WaitUntilOnEnded());
1616 }
1617
1618 // Verify that OPUS audio in a webm which reports a 44.1kHz sample rate plays
1619 // correctly at 48kHz
1620 TEST_F(PipelineIntegrationTest, BasicPlayback_Opus441kHz) {
1621   ASSERT_EQ(PIPELINE_OK, Start("sfx-opus-441.webm"));
1622   Play();
1623   ASSERT_TRUE(WaitUntilOnEnded());
1624   EXPECT_EQ(48000,
1625             demuxer_->GetStream(DemuxerStream::AUDIO)
1626                 ->audio_decoder_config()
1627                 .samples_per_second());
1628 }
1629
1630 // Same as above but using MediaSource.
1631 TEST_F(PipelineIntegrationTest, BasicPlayback_MediaSource_Opus441kHz) {
1632   MockMediaSource source(
1633       "sfx-opus-441.webm", kOpusAudioOnlyWebM, kAppendWholeFile);
1634   StartPipelineWithMediaSource(&source);
1635   source.EndOfStream();
1636   Play();
1637   ASSERT_TRUE(WaitUntilOnEnded());
1638   source.Abort();
1639   Stop();
1640   EXPECT_EQ(48000,
1641             demuxer_->GetStream(DemuxerStream::AUDIO)
1642                 ->audio_decoder_config()
1643                 .samples_per_second());
1644 }
1645
1646 // Ensures audio-only playback with missing or negative timestamps works.  Tests
1647 // the common live-streaming case for chained ogg.  See http://crbug.com/396864.
1648 TEST_F(PipelineIntegrationTest, BasicPlaybackChainedOgg) {
1649   ASSERT_EQ(PIPELINE_OK, Start("double-sfx.ogg"));
1650   Play();
1651   ASSERT_TRUE(WaitUntilOnEnded());
1652   ASSERT_EQ(base::TimeDelta(), demuxer_->GetStartTime());
1653 }
1654
1655 // Ensures audio-video playback with missing or negative timestamps fails softly
1656 // instead of crashing.  See http://crbug.com/396864.
1657 TEST_F(PipelineIntegrationTest, BasicPlaybackChainedOggVideo) {
1658   ASSERT_EQ(PIPELINE_OK, Start("double-bear.ogv"));
1659   Play();
1660   EXPECT_EQ(PIPELINE_ERROR_DECODE, WaitUntilEndedOrError());
1661   ASSERT_EQ(base::TimeDelta(), demuxer_->GetStartTime());
1662 }
1663
1664 // Tests that we signal ended even when audio runs longer than video track.
1665 TEST_F(PipelineIntegrationTest, BasicPlaybackAudioLongerThanVideo) {
1666   ASSERT_EQ(PIPELINE_OK, Start("bear_audio_longer_than_video.ogv"));
1667   // Audio track is 2000ms. Video track is 1001ms. Duration should be higher
1668   // of the two.
1669   EXPECT_EQ(2000, pipeline_->GetMediaDuration().InMilliseconds());
1670   Play();
1671   ASSERT_TRUE(WaitUntilOnEnded());
1672 }
1673
1674 // Tests that we signal ended even when audio runs shorter than video track.
1675 TEST_F(PipelineIntegrationTest, BasicPlaybackAudioShorterThanVideo) {
1676   ASSERT_EQ(PIPELINE_OK, Start("bear_audio_shorter_than_video.ogv"));
1677   // Audio track is 500ms. Video track is 1001ms. Duration should be higher of
1678   // the two.
1679   EXPECT_EQ(1001, pipeline_->GetMediaDuration().InMilliseconds());
1680   Play();
1681   ASSERT_TRUE(WaitUntilOnEnded());
1682 }
1683
1684 TEST_F(PipelineIntegrationTest, BasicPlaybackPositiveStartTime) {
1685   ASSERT_EQ(PIPELINE_OK, Start("nonzero-start-time.webm"));
1686   Play();
1687   ASSERT_TRUE(WaitUntilOnEnded());
1688   ASSERT_EQ(base::TimeDelta::FromMicroseconds(396000),
1689             demuxer_->GetStartTime());
1690 }
1691
1692 }  // namespace media