PpapiDecryptor: Call NewKeyCB on OnSessionReady().

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
+// 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 <string>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/debug/trace_event.h"
 #include "base/logging.h"
 #include "base/time/time.h"
 #include "media/base/decoder_buffer.h"
 #include "media/base/decrypt_config.h"
@@ skipping 171 matching lines @@
           base::Bind(&ClearKeyCdm::OnSessionCreated, base::Unretained(this)),
           base::Bind(&ClearKeyCdm::OnSessionMessage, base::Unretained(this)),
           base::Bind(&ClearKeyCdm::OnSessionReady, base::Unretained(this)),
           base::Bind(&ClearKeyCdm::OnSessionClosed, base::Unretained(this)),
           base::Bind(&ClearKeyCdm::OnSessionError, base::Unretained(this))),
       host_(host),
       key_system_(key_system),
       last_session_id_(MediaKeys::kInvalidSessionId),
       session_id_for_emulated_loadsession_(MediaKeys::kInvalidSessionId),
       timer_delay_ms_(kInitialTimerDelayMs),
-      timer_set_(false) {
+      heartbeat_timer_set_(false) {
 #if defined(CLEAR_KEY_CDM_USE_FAKE_AUDIO_DECODER)
   channel_count_ = 0;
   bits_per_channel_ = 0;
   samples_per_second_ = 0;
   output_timestamp_base_in_microseconds_ = kNoTimestamp;
   total_samples_generated_ = 0;
 #endif  // CLEAR_KEY_CDM_USE_FAKE_AUDIO_DECODER
 }
 
 ClearKeyCdm::~ClearKeyCdm() {}
@@ skipping 33 matching lines @@
 
   decryptor_.CreateSession(session_id, kLoadableSessionContentType, NULL, 0);
 }
 
 void ClearKeyCdm::UpdateSession(uint32 session_id,
                                 const uint8* response,
                                 uint32 response_size) {
   DVLOG(1) << __FUNCTION__;
   decryptor_.UpdateSession(session_id, response, response_size);
 
-  if (!timer_set_) {
+  if (!heartbeat_timer_set_) {
     ScheduleNextHeartBeat();
-    timer_set_ = true;
+    heartbeat_timer_set_ = true;
   }
 }
 
 void ClearKeyCdm::ReleaseSession(uint32 session_id) {
   DVLOG(1) << __FUNCTION__;
   decryptor_.ReleaseSession(session_id);
 }
 
 void ClearKeyCdm::TimerExpired(void* context) {
+  if (context == &session_id_for_emulated_loadsession_) {
+    LoadLoadableSession();
+    return;
+  }
+
+  DCHECK(heartbeat_timer_set_);
   std::string heartbeat_message;
   if (!next_heartbeat_message_.empty() &&
       context == &next_heartbeat_message_[0]) {
     heartbeat_message = next_heartbeat_message_;
   } else {
     heartbeat_message = "ERROR: Invalid timer context found!";
   }
 
   // This URL is only used for testing the code path for defaultURL.
   // There is no service at this URL, so applications should ignore it.
@@ skipping 239 matching lines @@
 void ClearKeyCdm::OnPlatformChallengeResponse(
     const cdm::PlatformChallengeResponse& response) {
   NOTIMPLEMENTED();
 }
 
 void ClearKeyCdm::OnQueryOutputProtectionStatus(
     uint32_t link_mask, uint32_t output_protection_mask) {
   NOTIMPLEMENTED();
 };
 
-void ClearKeyCdm::UpdateLoadableSession() {
+void ClearKeyCdm::LoadLoadableSession() {
   std::string jwk_set = GenerateJWKSet(kLoadableSessionKey,
                                        sizeof(kLoadableSessionKey),
                                        kLoadableSessionKeyId,
                                        sizeof(kLoadableSessionKeyId) - 1);
   // TODO(xhwang): This triggers OnSessionUpdated(). For prefixed EME support,
   // this is okay. Check WD EME support.
   decryptor_.UpdateSession(session_id_for_emulated_loadsession_,
                            reinterpret_cast<const uint8*>(jwk_set.data()),
                            jwk_set.size());
 }
 
 void ClearKeyCdm::OnSessionCreated(uint32 session_id,
                                    const std::string& web_session_id) {
   std::string new_web_session_id = web_session_id;
 
   if (session_id == session_id_for_emulated_loadsession_) {
-    new_web_session_id = kLoadableWebSessionId;
-    UpdateLoadableSession();
-    session_id_for_emulated_loadsession_ = MediaKeys::kInvalidSessionId;
+    // Delay LoadLoadableSession() to test the case where Decrypt*() calls are
+    // made before the session is fully loaded.
+    const int64 kDelayToLoadSessionMs = 500;
+    // Use the address of |session_id_for_emulated_loadsession_| as the timer
+    // context so that we can call LoadLoadableSession() when the timer expires.
+    host_->SetTimer(kDelayToLoadSessionMs,
+                    &session_id_for_emulated_loadsession_);
+    // Defer OnSessionCreated() until the session is loaded with
+    // kLoadableSessionKey.

[ddorwin, 2014/02/19 00:38:13]

nit: The fact that it is loaded with this specific key is irrelevant to our
decision here, right? Just drop " with kLoadableSessionKey"?

[xhwang, 2014/02/19 00:46:42]

Done.

+    return;
   }
 
   host_->OnSessionCreated(
-      session_id, new_web_session_id.data(), new_web_session_id.size());
+      session_id, web_session_id.data(), web_session_id.size());
 }
 
 void ClearKeyCdm::OnSessionMessage(uint32 session_id,
                                    const std::vector<uint8>& message,
                                    const std::string& destination_url) {
+  DVLOG(1) << "OnSessionMessage: " << message.size();
+
+  // Ignore the message when we are waiting to update the loadable session.
+  if (session_id == session_id_for_emulated_loadsession_)
+    return;
+
   host_->OnSessionMessage(session_id,
                           reinterpret_cast<const char*>(message.data()),
                           message.size(),
                           destination_url.data(),
                           destination_url.size());
 }
 
 void ClearKeyCdm::OnSessionReady(uint32 session_id) {
+  if (session_id == session_id_for_emulated_loadsession_) {
+    session_id_for_emulated_loadsession_ = MediaKeys::kInvalidSessionId;
+    host_->OnSessionCreated(
+        session_id, kLoadableWebSessionId, strlen(kLoadableWebSessionId));
+  }
+
   host_->OnSessionReady(session_id);
 }
 
 void ClearKeyCdm::OnSessionClosed(uint32 session_id) {
   host_->OnSessionClosed(session_id);
 }
 
 void ClearKeyCdm::OnSessionError(uint32 session_id,
                                  media::MediaKeys::KeyError error_code,
                                  int system_code) {
@@ skipping 69 matching lines @@
 
 void ClearKeyCdm::OnFileIOTestComplete(bool success) {
   DVLOG(1) << __FUNCTION__ << ": " << success;
   std::string message = GetFileIOTestResultMessage(success);
   host_->OnSessionMessage(
       last_session_id_, message.data(), message.size(), NULL, 0);
   file_io_test_runner_.reset();
 }
 
 }  // namespace media