Support HLS MPEG2 TS with SAMPLE-AES encryption.

media/test/pipeline_integration_test.cc

 // Copyright (c) 2012 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 <stddef.h>
 #include <stdint.h>
 
 #include <memory>
 #include <utility>
 
@@ skipping 95 matching lines @@
 const char kMP4VideoAVC3[] = "video/mp4; codecs=\"avc3.64001f\"";
 const char kMP4VideoVP9[] = "video/mp4; codecs=\"vp09.00.00.08.01.01.00.00\"";
 const char kMP4VideoHEVC1[] = "video/mp4; codecs=\"hvc1.1.6.L93.B0\"";
 const char kMP4VideoHEVC2[] = "video/mp4; codecs=\"hev1.1.6.L93.B0\"";
 const char kMP4Video[] = "video/mp4; codecs=\"avc1.4D4041\"";
 const char kMP4Audio[] = "audio/mp4; codecs=\"mp4a.40.2\"";
 const char kMP3[] = "audio/mpeg";
 const char kMP2AudioSBR[] = "video/mp2t; codecs=\"avc1.4D4041,mp4a.40.5\"";
 #endif  // defined(USE_PROPRIETARY_CODECS)
 
-// Key used to encrypt test files.
-const uint8_t kSecretKey[] = {0xeb, 0xdd, 0x62, 0xf1, 0x68, 0x14, 0xd2, 0x7b,
-                              0x68, 0xef, 0x12, 0x2a, 0xfc, 0xe4, 0xae, 0x3c};
-
-// The key ID for all encrypted files.
-const uint8_t kKeyId[] = {0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37,
-                          0x38, 0x39, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35};
-
 const size_t kAppendWholeFile = std::numeric_limits<size_t>::max();
 
 // Constants for the Media Source config change tests.
 const int kAppendTimeSec = 1;
 const int kAppendTimeMs = kAppendTimeSec * 1000;
 const int k320WebMFileDurationMs = 2736;
 const int k320EncWebMFileDurationMs = 2737;
 const int k640WebMFileDurationMs = 2749;
 const int kOpusEndTrimmingWebMFileDurationMs = 2741;
 const int kVP9WebMFileDurationMs = 2736;
@@ skipping 124 matching lines @@
     Decryptor* decryptor_;
   };
 
   scoped_refptr<AesDecryptor> decryptor_;
   TestCdmContext cdm_context_;
   std::unique_ptr<AppBase> app_;
 };
 
 enum PromiseResult { RESOLVED, REJECTED };
 
-// Provides |kSecretKey| in response to the encrypted event.
+// Provides the test key in response to the encrypted event.
 class KeyProvidingApp : public FakeEncryptedMedia::AppBase {
  public:
   KeyProvidingApp() {}
 
   void OnResolveWithSession(PromiseResult expected,
                             const std::string& session_id) {
     EXPECT_EQ(expected, RESOLVED);
     EXPECT_GT(session_id.length(), 0ul);
     current_session_id_ = session_id;
   }
@@ skipping 82 matching lines @@
     if (current_session_id_.empty()) {
       decryptor->CreateSessionAndGenerateRequest(
           MediaKeys::TEMPORARY_SESSION, init_data_type, init_data,
           CreateSessionPromise(RESOLVED));
       EXPECT_FALSE(current_session_id_.empty());
     }
   }
 
   virtual bool LookupKey(const std::vector<uint8_t>& key_id,
                          std::vector<uint8_t>* key) {
-    // As there is no key rotation, the key ID provided should be |kKeyId|
-    // which uses |kSecretKey| as the key.
-    EXPECT_EQ(std::vector<uint8_t>(kKeyId, kKeyId + arraysize(kKeyId)), key_id);
-    key->assign(kSecretKey, kSecretKey + arraysize(kSecretKey));
-    return true;
+    // No key rotation.
+    return LookupTestKeyVector(key_id, false, key);
   }
 
   std::string current_session_id_;
   std::vector<uint8_t> prev_init_data_;
 };
 
 class RotatingKeyProvidingApp : public KeyProvidingApp {
  public:
   RotatingKeyProvidingApp() : num_distinct_need_key_calls_(0) {}
   ~RotatingKeyProvidingApp() override {
@@ skipping 11 matching lines @@
     prev_init_data_ = init_data;
     ++num_distinct_need_key_calls_;
 
     decryptor->CreateSessionAndGenerateRequest(MediaKeys::TEMPORARY_SESSION,
                                                init_data_type, init_data,
                                                CreateSessionPromise(RESOLVED));
   }
 
   bool LookupKey(const std::vector<uint8_t>& key_id,
                  std::vector<uint8_t>* key) override {
-    // The Key and KeyId for this testing key provider are created by left
-    // rotating |kSecretKey| and |kKeyId|. Note that this implementation is
-    // only intended for testing purpose. The actual key rotation algorithm
-    // can be much more complicated.
-    // Find out the rotating position from |starting_key_id| and apply on |key|.
-    std::vector<uint8_t> starting_key_id(kKeyId, kKeyId + arraysize(kKeyId));
-    for (size_t pos = 0; pos < starting_key_id.size(); ++pos) {
-      std::rotate(starting_key_id.begin(), starting_key_id.begin() + pos,
-                  starting_key_id.end());
-      if (key_id == starting_key_id) {
-        key->assign(kSecretKey, kSecretKey + arraysize(kSecretKey));
-        std::rotate(key->begin(), key->begin() + pos, key->end());
-        return true;
-      }
-    }
-    return false;
+    // With key rotation.
+    return LookupTestKeyVector(key_id, true, key);
   }
 
   uint32_t num_distinct_need_key_calls_;
 };
 
 // Ignores the encrypted event and does not perform a license request.
 class NoResponseApp : public FakeEncryptedMedia::AppBase {
  public:
   void OnSessionMessage(const std::string& session_id,
                         MediaKeys::MessageType message_type,
@@ skipping 2075 matching lines @@
 
 TEST_F(PipelineIntegrationTest, BasicPlaybackPositiveStartTime) {
   ASSERT_EQ(PIPELINE_OK, Start("nonzero-start-time.webm"));
   Play();
   ASSERT_TRUE(WaitUntilOnEnded());
   ASSERT_EQ(base::TimeDelta::FromMicroseconds(396000),
             demuxer_->GetStartTime());
 }
 
 }  // namespace media