Update ClearKey to support CDM_6

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>
@@ skipping 77 matching lines @@
 const int64 kMaxTimerDelayMs = 1 * kSecondsPerMinute * kMsPerSecond;
 // Heart beat message header. If a key message starts with |kHeartBeatHeader|,
 // it's a heart beat message. Otherwise, it's a key request.
 const char kHeartBeatHeader[] = "HEARTBEAT";
 // CDM file IO test result header.
 const char kFileIOTestResultHeader[] = "FILEIOTESTRESULT";
 
 // Copies |input_buffer| into a media::DecoderBuffer. If the |input_buffer| is
 // empty, an empty (end-of-stream) media::DecoderBuffer is returned.
 static scoped_refptr<media::DecoderBuffer> CopyDecoderBufferFrom(
-    const cdm::InputBuffer_1& input_buffer) {
+    const cdm::InputBuffer& input_buffer) {
   if (!input_buffer.data) {
     DCHECK(!input_buffer.data_size);
     return media::DecoderBuffer::CreateEOSBuffer();
   }
 
   // TODO(xhwang): Get rid of this copy.
   scoped_refptr<media::DecoderBuffer> output_buffer =
       media::DecoderBuffer::CopyFrom(input_buffer.data, input_buffer.data_size);
 
   std::vector<media::SubsampleEntry> subsamples;
   for (uint32_t i = 0; i < input_buffer.num_subsamples; ++i) {
     media::SubsampleEntry subsample;
     subsample.clear_bytes = input_buffer.subsamples[i].clear_bytes;
     subsample.cypher_bytes = input_buffer.subsamples[i].cipher_bytes;
     subsamples.push_back(subsample);
   }
 
-  DCHECK_EQ(input_buffer.data_offset, 0u);
   scoped_ptr<media::DecryptConfig> decrypt_config(new media::DecryptConfig(
       std::string(reinterpret_cast<const char*>(input_buffer.key_id),
                   input_buffer.key_id_size),
       std::string(reinterpret_cast<const char*>(input_buffer.iv),
                   input_buffer.iv_size),
       subsamples));
 
   output_buffer->set_decrypt_config(decrypt_config.Pass());
   output_buffer->set_timestamp(
       base::TimeDelta::FromMicroseconds(input_buffer.timestamp));
@@ skipping 140 matching lines @@
 // (containing a |kLoadableSessionKey| for |kLoadableSessionKeyId|) is
 // supported.
 void ClearKeyCdm::LoadSession(uint32 promise_id,
                               const char* web_session_id,
                               uint32_t web_session_id_length) {
   DVLOG(1) << __FUNCTION__;
 
   if (std::string(kLoadableWebSessionId) !=
       std::string(web_session_id, web_session_id_length)) {
     std::string message("Incorrect session id specified for LoadSession().");
     host_->OnRejectPromise(promise_id,

[ddorwin, 2014/08/08 23:36:25]

Separate CL: This should be resolved with undefined. (Not sure how we'd then
handle that in prefixed or if we need to. I guess we could handle resolved with
undefined/0/null as a failure for prefixed.)

[jrummell, 2014/08/11 18:59:04]

Added TODO.

                            cdm::kInvalidAccessError,
                            0,
                            message.data(),
                            message.length());
     return;
   }
 
   scoped_ptr<media::NewSessionCdmPromise> promise(
       new media::NewSessionCdmPromise(base::Bind(&ClearKeyCdm::OnSessionLoaded,
                                                  base::Unretained(this),
                                                  promise_id),
                                       base::Bind(&ClearKeyCdm::OnPromiseFailed,
                                                  base::Unretained(this),
                                                  promise_id)));
   decryptor_.CreateSession(std::string(kLoadableSessionContentType),
                            NULL,
                            0,
                            MediaKeys::TEMPORARY_SESSION,
                            promise.Pass());
 }
 
 void ClearKeyCdm::UpdateSession(uint32 promise_id,
                                 const char* web_session_id,
-                                uint32_t web_session_id_size,
+                                uint32_t web_session_id_length,
                                 const uint8* response,
                                 uint32 response_size) {
   DVLOG(1) << __FUNCTION__;
-  std::string web_session_str(web_session_id, web_session_id_size);
+  std::string web_session_str(web_session_id, web_session_id_length);
 
   scoped_ptr<media::SimpleCdmPromise> promise(new media::SimpleCdmPromise(
       base::Bind(&ClearKeyCdm::OnSessionUpdated,
                  base::Unretained(this),
                  promise_id,
                  web_session_str),
       base::Bind(
           &ClearKeyCdm::OnPromiseFailed, base::Unretained(this), promise_id)));
   decryptor_.UpdateSession(
       web_session_str, response, response_size, promise.Pass());
 
   if (!heartbeat_timer_set_) {
     ScheduleNextHeartBeat();
     heartbeat_timer_set_ = true;
   }
 }
 
-void ClearKeyCdm::ReleaseSession(uint32 promise_id,
-                                 const char* web_session_id,
-                                 uint32_t web_session_id_size) {
+void ClearKeyCdm::CloseSession(uint32 promise_id,
+                               const char* web_session_id,
+                               uint32_t web_session_id_length) {
   DVLOG(1) << __FUNCTION__;
-  std::string web_session_str(web_session_id, web_session_id_size);
+  std::string web_session_str(web_session_id, web_session_id_length);
 
   scoped_ptr<media::SimpleCdmPromise> promise(new media::SimpleCdmPromise(
       base::Bind(&ClearKeyCdm::OnSessionReleased,
                  base::Unretained(this),
                  promise_id,
                  web_session_str),
       base::Bind(
           &ClearKeyCdm::OnPromiseFailed, base::Unretained(this), promise_id)));
   decryptor_.ReleaseSession(web_session_str, promise.Pass());
 }
 
+void ClearKeyCdm::RemoveSession(uint32 promise_id,
+                                const char* web_session_id,
+                                uint32_t web_session_id_length) {
+  DVLOG(1) << __FUNCTION__;
+  // RemoveSession only allowed for the simulated loadable session.

[ddorwin, 2014/08/08 23:36:25]

Really, the session must be persistent. How about this?

// Similar comment to the one above.
bool is_persistent_session = std::string(kLoadableWebSessionId) ==
std::string(web_session_id, web_session_id_length);
if (is_persistent_session) {
  resolve...

[jrummell, 2014/08/11 18:59:04]

Done.

+  if (std::string(kLoadableWebSessionId) ==
+      std::string(web_session_id, web_session_id_length)) {
+    host_->OnResolvePromise(promise_id);
+  } else {
+    std::string message("Incorrect session id specified for RemoveSession().");

[ddorwin, 2014/08/08 23:36:25]

"Not supported for non-persistent sessions."

[jrummell, 2014/08/11 18:59:04]

Done.

+    host_->OnRejectPromise(promise_id,
+                           cdm::kInvalidAccessError,
+                           0,
+                           message.data(),
+                           message.length());
+  }
+}
+
 void ClearKeyCdm::SetServerCertificate(uint32 promise_id,
                                        const uint8_t* server_certificate_data,
                                        uint32_t server_certificate_data_size) {
   // ClearKey doesn't use a server certificate.
   host_->OnResolvePromise(promise_id);
 }
 
+void ClearKeyCdm::GetUsableKeyIds(uint32_t promise_id,
+                                  const char* web_session_id,
+                                  uint32_t web_session_id_length) {
+  std::string web_session_str(web_session_id, web_session_id_length);
+  scoped_ptr<media::KeyIdsPromise> promise(new media::KeyIdsPromise(
+      base::Bind(&ClearKeyCdm::OnUsableKeyIdsObtained,
+                 base::Unretained(this),
+                 promise_id),
+      base::Bind(
+          &ClearKeyCdm::OnPromiseFailed, base::Unretained(this), promise_id)));
+  decryptor_.GetUsableKeyIds(web_session_str, promise.Pass());
+}
+
 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]) {
@@ skipping 18 matching lines @@
 
 static void CopyDecryptResults(
     media::Decryptor::Status* status_copy,
     scoped_refptr<media::DecoderBuffer>* buffer_copy,
     media::Decryptor::Status status,
     const scoped_refptr<media::DecoderBuffer>& buffer) {
   *status_copy = status;
   *buffer_copy = buffer;
 }
 
-cdm::Status ClearKeyCdm::Decrypt(const cdm::InputBuffer_1& encrypted_buffer,
+cdm::Status ClearKeyCdm::Decrypt(const cdm::InputBuffer& encrypted_buffer,
                                  cdm::DecryptedBlock* decrypted_block) {
   DVLOG(1) << "Decrypt()";
   DCHECK(encrypted_buffer.data);
 
   scoped_refptr<media::DecoderBuffer> buffer;
   cdm::Status status = DecryptToMediaDecoderBuffer(encrypted_buffer, &buffer);
 
   if (status != cdm::kSuccess)
     return status;
 
@@ skipping 85 matching lines @@
       output_timestamp_base_in_microseconds_ = kNoTimestamp;
       total_samples_generated_ = 0;
 #endif
       break;
     default:
       NOTREACHED() << "DeinitializeDecoder(): invalid cdm::StreamType";
   }
 }
 
 cdm::Status ClearKeyCdm::DecryptAndDecodeFrame(
-    const cdm::InputBuffer_1& encrypted_buffer,
+    const cdm::InputBuffer& encrypted_buffer,
     cdm::VideoFrame* decoded_frame) {
   DVLOG(1) << "DecryptAndDecodeFrame()";
   TRACE_EVENT0("media", "ClearKeyCdm::DecryptAndDecodeFrame");
 
   scoped_refptr<media::DecoderBuffer> buffer;
   cdm::Status status = DecryptToMediaDecoderBuffer(encrypted_buffer, &buffer);
 
   if (status != cdm::kSuccess)
     return status;
 
   const uint8_t* data = NULL;
   int32_t size = 0;
   int64_t timestamp = 0;
   if (!buffer->end_of_stream()) {
     data = buffer->data();
     size = buffer->data_size();
     timestamp = encrypted_buffer.timestamp;
   }
 
   return video_decoder_->DecodeFrame(data, size, timestamp, decoded_frame);
 }
 
 cdm::Status ClearKeyCdm::DecryptAndDecodeSamples(
-    const cdm::InputBuffer_1& encrypted_buffer,
+    const cdm::InputBuffer& encrypted_buffer,
     cdm::AudioFrames* audio_frames) {
   DVLOG(1) << "DecryptAndDecodeSamples()";
 
   // Trigger a crash on purpose for testing purpose.
   if (key_system_ == kExternalClearKeyCrashKeySystem)
     CHECK(false);
 
   scoped_refptr<media::DecoderBuffer> buffer;
   cdm::Status status = DecryptToMediaDecoderBuffer(encrypted_buffer, &buffer);
 
@@ skipping 25 matching lines @@
 
 void ClearKeyCdm::Destroy() {
   DVLOG(1) << "Destroy()";
   delete this;
 }
 
 void ClearKeyCdm::ScheduleNextHeartBeat() {
   // Prepare the next heartbeat message and set timer.
   std::ostringstream msg_stream;
   msg_stream << kHeartBeatHeader << " from ClearKey CDM set at time "
-             << host_->GetCurrentTime() << ".";
+             << host_->GetCurrentWallTime() << ".";
   next_heartbeat_message_ = msg_stream.str();
 
   host_->SetTimer(timer_delay_ms_, &next_heartbeat_message_[0]);
 
   // Use a smaller timer delay at start-up to facilitate testing. Increase the
   // timer delay up to a limit to avoid message spam.
   if (timer_delay_ms_ < kMaxTimerDelayMs)
     timer_delay_ms_ = std::min(2 * timer_delay_ms_, kMaxTimerDelayMs);
 }
 
 cdm::Status ClearKeyCdm::DecryptToMediaDecoderBuffer(
-    const cdm::InputBuffer_1& encrypted_buffer,
+    const cdm::InputBuffer& encrypted_buffer,
     scoped_refptr<media::DecoderBuffer>* decrypted_buffer) {
   DCHECK(decrypted_buffer);
   scoped_refptr<media::DecoderBuffer> buffer =
       CopyDecoderBufferFrom(encrypted_buffer);
 
   if (buffer->end_of_stream()) {
     *decrypted_buffer = buffer;
     return cdm::kSuccess;
   }
 
@@ skipping 97 matching lines @@
   // Defer resolving the promise until the session is loaded.
   promise_id_for_emulated_loadsession_ = promise_id;
 
   // 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_);
 }
 
 void ClearKeyCdm::OnSessionUpdated(uint32 promise_id,
                                    const std::string& web_session_id) {
-  // OnSessionReady() only called as success for UpdateSession(). However,
-  // UpdateSession() also called to finish loading sessions, so handle
+  // UpdateSession() may be called to finish loading sessions, so handle

[ddorwin, 2014/08/08 23:36:25]

I wonder what this means. Is itan artifact of the prefixed implementation?

[jrummell, 2014/08/11 18:59:04]

It's part of simulating LoadSession().

   // appropriately.
   if (web_session_id == session_id_for_emulated_loadsession_) {
     session_id_for_emulated_loadsession_ = std::string();

[ddorwin, 2014/08/08 23:36:25]

Separate CL: Do we need session_id_for_emulated_loadsession_ or can we just use
kLoadableWebSessionId? Maybe this is left over from the reference_id days.

[jrummell, 2014/08/11 18:59:03]

I think this is needed by the simulated LoadSession(). aes_decryptor will create
the session using a number (e.g. "1"), yet we need to return
kLoadableWebSessionId as the session id to the callers. This keeps track of the
mapping.

     // |promise_id| is the LoadSession() promise, so resolve appropriately.
     host_->OnResolveNewSessionPromise(
         promise_id, kLoadableWebSessionId, strlen(kLoadableWebSessionId));
-    host_->OnSessionReady(kLoadableWebSessionId, strlen(kLoadableWebSessionId));
     return;
   }
 
   host_->OnResolvePromise(promise_id);
 }
 
 void ClearKeyCdm::OnSessionReleased(uint32 promise_id,
                                     const std::string& web_session_id) {
   host_->OnResolvePromise(promise_id);
 }
 
+void ClearKeyCdm::OnUsableKeyIdsObtained(uint32 promise_id,
+                                         const KeyIdsVector& key_ids) {
+  scoped_ptr<cdm::BinaryData[]> result(new cdm::BinaryData[key_ids.size()]);
+  for (uint32 i = 0; i < key_ids.size(); ++i) {
+    result[i].data = key_ids[i].data();
+    result[i].length = key_ids[i].size();
+  }
+  host_->OnResolveKeyIdsPromise(promise_id, result.get(), key_ids.size());

[ddorwin, 2014/08/08 23:36:25]

result.size()

[jrummell, 2014/08/11 18:59:03]

Not done. No operators on scoped_ptr<T[]> return the array size. .get() simply
returns T*, so arraysize() doesn't work.

+}
+
 void ClearKeyCdm::OnPromiseFailed(uint32 promise_id,
                                   MediaKeys::Exception exception_code,
                                   uint32 system_code,
                                   const std::string& error_message) {
   host_->OnRejectPromise(promise_id,
                          ConvertException(exception_code),
                          system_code,
                          error_message.data(),
                          error_message.length());
 }
@@ skipping 70 matching lines @@
   host_->OnSessionMessage(last_session_id_.data(),
                           last_session_id_.length(),
                           message.data(),
                           message.length(),
                           NULL,
                           0);
   file_io_test_runner_.reset();
 }
 
 }  // namespace media