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

media/cdm/ppapi/external_clear_key/clear_key_cdm.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.
 
 #include "media/cdm/ppapi/external_clear_key/clear_key_cdm.h"
 
 #include <algorithm>
 #include <cstring>
 #include <sstream>
 #include <utility>
@@ skipping 312 matching lines @@
 
 namespace media {
 
 ClearKeyCdm::ClearKeyCdm(ClearKeyCdmHost* host,
                          const std::string& key_system,
                          const GURL& origin)
     : decryptor_(new AesDecryptor(
           origin,
           base::Bind(&ClearKeyCdm::OnSessionMessage, base::Unretained(this)),
           base::Bind(&ClearKeyCdm::OnSessionClosed, base::Unretained(this)),
-          base::Bind(&ClearKeyCdm::OnSessionKeysChange,
+          base::Bind(&ClearKeyCdm::OnSessionKeysChange, base::Unretained(this)),
+          base::Bind(&ClearKeyCdm::OnSessionExpirationUpdate,
                      base::Unretained(this)))),
       host_(host),
       key_system_(key_system),
       has_received_keys_change_event_for_emulated_loadsession_(false),
       timer_delay_ms_(kInitialTimerDelayMs),
       renewal_timer_set_(false),
       is_running_output_protection_test_(false),
       is_running_platform_verification_test_(false) {
 #if defined(CLEAR_KEY_CDM_USE_FAKE_AUDIO_DECODER)
   channel_count_ = 0;
@@ skipping 138 matching lines @@
   decryptor_->CloseSession(web_session_str, std::move(promise));
 }
 
 void ClearKeyCdm::RemoveSession(uint32_t promise_id,
                                 const char* session_id,
                                 uint32_t session_id_length) {
   DVLOG(1) << __func__;
   std::string web_session_str(session_id, session_id_length);
 
   // RemoveSession only allowed for the loadable session.
-  if (web_session_str == std::string(kLoadableSessionId)) {
+  if (web_session_str == std::string(kLoadableSessionId))
     web_session_str = session_id_for_emulated_loadsession_;
-  } else {
-    // TODO(jrummell): This should be a DCHECK once blink does the proper
-    // checks.
-    std::string message("Not supported for non-persistent sessions.");
-    host_->OnRejectPromise(promise_id,
-                           cdm::kInvalidAccessError,
-                           0,
-                           message.data(),
-                           message.length());
-    return;
-  }
 
   std::unique_ptr<media::SimpleCdmPromise> promise(
       new media::CdmCallbackPromise<>(
           base::Bind(&ClearKeyCdm::OnPromiseResolved, base::Unretained(this),
                      promise_id),
           base::Bind(&ClearKeyCdm::OnPromiseFailed, base::Unretained(this),
                      promise_id)));
   decryptor_->RemoveSession(web_session_str, std::move(promise));
 }
 
@@ skipping 370 matching lines @@
                              keys_vector.size());
 }
 
 void ClearKeyCdm::OnSessionClosed(const std::string& session_id) {
   std::string new_session_id = session_id;
   if (new_session_id == session_id_for_emulated_loadsession_)
     new_session_id = std::string(kLoadableSessionId);
   host_->OnSessionClosed(new_session_id.data(), new_session_id.length());
 }
 
+void ClearKeyCdm::OnSessionExpirationUpdate(const std::string& session_id,
+                                            base::Time new_expiry_time) {
+  std::string new_session_id = session_id;
+  if (new_session_id == session_id_for_emulated_loadsession_)
+    new_session_id = std::string(kLoadableSessionId);
+  host_->OnExpirationChange(new_session_id.data(), new_session_id.length(),
+                            new_expiry_time.ToDoubleT());
+}
+
 void ClearKeyCdm::OnSessionCreated(uint32_t promise_id,
                                    const std::string& session_id) {
   // Save the latest session ID for renewal and file IO test messages.
   last_session_id_ = session_id;
 
   host_->OnResolveNewSessionPromise(promise_id, session_id.data(),
                                     session_id.length());
 }
 
 void ClearKeyCdm::OnSessionLoaded(uint32_t promise_id,
@@ skipping 160 matching lines @@
                                challenge.data(), challenge.size());
 }
 
 void ClearKeyCdm::VerifyCdmHostTest() {
   // VerifyCdmHost() should have already been called and test result stored
   // in |g_verify_host_files_result|.
   OnUnitTestComplete(g_verify_host_files_result);
 }
 
 }  // namespace media