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
 // 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_) {
+    UpdateLoadableSession();
+    return;
+  }
+
   std::string heartbeat_message;

[ddorwin, 2014/02/19 00:04:09]

Should we add this before this line?
DCHECK(heartbeat_timer_set_);

[xhwang, 2014/02/19 00:24:23]

Done.

   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.
   const char url[] = "http://test.externalclearkey.chromium.org";
@@ skipping 238 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() {

[ddorwin, 2014/02/19 00:04:09]

I think we need a better name for this. Update() is an implementation detail of
how we load/initialize the loadable session. How about LoadLoadableSession()? A
bit weird. Could do InitializeLoadableSession().

[xhwang, 2014/02/19 00:24:23]

Done.

   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 UpdateLoadableSession() to test the case where Decrypt*() calls are
+    // made before the session is fully loaded.
+    const int64 kDelayToLoadSessionMs = 500;

[xhwang, 2014/02/18 23:19:16]

Ideally we should keep the old test (where the delay is 0). But that requires a
new key system to be passed in. I am not sure if it's worth the effort... WDYT?

+    host_->SetTimer(kDelayToLoadSessionMs,
+                    &session_id_for_emulated_loadsession_);

[ddorwin, 2014/02/19 00:04:09]

It might be nice to clarify somewhere that we're using the address of this
member as an indication to call UpdateLoadableSession().

[xhwang, 2014/02/19 00:24:23]

Done.

+    // Defer OnSessionCreated until the session is updated with

[ddorwin, 2014/02/19 00:04:09]

... until the loadable session is initialized?

[xhwang, 2014/02/19 00:24:23]

Done.

+    // kLoadableSessionKey.
+    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.

[ddorwin, 2014/02/19 00:04:09]

nit: Is upper case 'M' intentional?

[xhwang, 2014/02/19 00:24:23]

Done.

+  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