EME: Allow temporary sessions to be removed for ClearKey only.

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 190 matching lines @@
         ContentDecryptionModule::MessageType message_type,
         const std::vector<uint8_t>& message,
         AesDecryptor* decryptor) = 0;
 
     virtual void OnSessionClosed(const std::string& session_id) = 0;
 
     virtual void OnSessionKeysChange(const std::string& session_id,
                                      bool has_additional_usable_key,
                                      CdmKeysInfo keys_info) = 0;
 
+    virtual void OnSessionExpirationUpdate(const std::string& session_id,
+                                           base::Time new_expiry_time) = 0;
+
     virtual void OnEncryptedMediaInitData(EmeInitDataType init_data_type,
                                           const std::vector<uint8_t>& init_data,
                                           AesDecryptor* decryptor) = 0;
   };
 
   FakeEncryptedMedia(AppBase* app)
       : decryptor_(new AesDecryptor(
             GURL::EmptyGURL(),
             base::Bind(&FakeEncryptedMedia::OnSessionMessage,
                        base::Unretained(this)),
             base::Bind(&FakeEncryptedMedia::OnSessionClosed,
                        base::Unretained(this)),
             base::Bind(&FakeEncryptedMedia::OnSessionKeysChange,
+                       base::Unretained(this)),
+            base::Bind(&FakeEncryptedMedia::OnSessionExpirationUpdate,
                        base::Unretained(this)))),
         cdm_context_(decryptor_.get()),
         app_(app) {}
 
   CdmContext* GetCdmContext() { return &cdm_context_; }
 
   // Callbacks for firing session events. Delegate to |app_|.
   void OnSessionMessage(const std::string& session_id,
                         ContentDecryptionModule::MessageType message_type,
                         const std::vector<uint8_t>& message) {
     app_->OnSessionMessage(session_id, message_type, message, decryptor_.get());
   }
 
   void OnSessionClosed(const std::string& session_id) {
     app_->OnSessionClosed(session_id);
   }
 
   void OnSessionKeysChange(const std::string& session_id,
                            bool has_additional_usable_key,
                            CdmKeysInfo keys_info) {
     app_->OnSessionKeysChange(session_id, has_additional_usable_key,
                               std::move(keys_info));
   }
 
+  void OnSessionExpirationUpdate(const std::string& session_id,
+                                 base::Time new_expiry_time) {
+    app_->OnSessionExpirationUpdate(session_id, new_expiry_time);
+  }
+
   void OnEncryptedMediaInitData(EmeInitDataType init_data_type,
                                 const std::vector<uint8_t>& init_data) {
     app_->OnEncryptedMediaInitData(init_data_type, init_data, decryptor_.get());
   }
 
  private:
   class TestCdmContext : public CdmContext {
    public:
     TestCdmContext(Decryptor* decryptor) : decryptor_(decryptor) {}
 
@@ skipping 89 matching lines @@
     EXPECT_EQ(current_session_id_, session_id);
   }
 
   void OnSessionKeysChange(const std::string& session_id,
                            bool has_additional_usable_key,
                            CdmKeysInfo keys_info) override {
     EXPECT_EQ(current_session_id_, session_id);
     EXPECT_EQ(has_additional_usable_key, true);
   }
 
+  void OnSessionExpirationUpdate(const std::string& session_id,
+                                 base::Time new_expiry_time) override {
+    EXPECT_EQ(current_session_id_, session_id);
+  }
+
   void OnEncryptedMediaInitData(EmeInitDataType init_data_type,
                                 const std::vector<uint8_t>& init_data,
                                 AesDecryptor* decryptor) override {
     // Since only 1 session is created, skip the request if the |init_data|
     // has been seen before (no need to add the same key again).
     if (init_data == prev_init_data_)
       return;
     prev_init_data_ = init_data;
 
     if (current_session_id_.empty()) {
@@ skipping 63 matching lines @@
     FAIL() << "Unexpected Closed";
   }
 
   void OnSessionKeysChange(const std::string& session_id,
                            bool has_additional_usable_key,
                            CdmKeysInfo keys_info) override {
     EXPECT_FALSE(session_id.empty());
     EXPECT_EQ(has_additional_usable_key, true);
   }
 
+  void OnSessionExpirationUpdate(const std::string& session_id,
+                                 base::Time new_expiry_time) override {}
+
   void OnEncryptedMediaInitData(EmeInitDataType init_data_type,
                                 const std::vector<uint8_t>& init_data,
                                 AesDecryptor* decryptor) override {}
 };
 
 // Helper class that emulates calls made on the ChunkDemuxer by the
 // Media Source API.
 class MockMediaSource {
  public:
   MockMediaSource(const std::string& filename,
@@ skipping 2222 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