Support LoadSession() in MediaKeys and PPP_ContentDecryptor_Private interface.

content/renderer/media/crypto/proxy_decryptor.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 "content/renderer/media/crypto/proxy_decryptor.h"
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/logging.h"
 #include "base/strings/string_util.h"
@@ skipping 65 matching lines @@
   DCHECK(!media_keys_);
   media_keys_ = CreateMediaKeys(key_system, frame_url);
   if (!media_keys_)
     return false;
 
   is_clear_key_ =
       media::IsClearKey(key_system) || media::IsExternalClearKey(key_system);
   return true;
 }
 
-bool ProxyDecryptor::GenerateKeyRequest(const std::string& type,
+bool ProxyDecryptor::GenerateKeyRequest(const std::string& content_type,
                                         const uint8* init_data,
                                         int init_data_length) {
   // Use a unique reference id for this request.
   uint32 session_id = next_session_id_++;
-  if (!media_keys_->CreateSession(
-           session_id, type, init_data, init_data_length)) {
-    return false;
+
+  const uint8 kPrefixedApiLoadSessionHeader[] = "LOAD_SESSION|";
+  const int kPrefixedApiLoadSessionHeaderLength =
+      sizeof(kPrefixedApiLoadSessionHeader) - 1;

[dcheng, 2014/02/11 23:12:25]

Nit: I'd prefer strlen here. It has the benefit of clarity, and it should be
evaluated at compile time by the compiler and not result in additional overhead
at runtime.

[xhwang, 2014/02/12 02:22:45]

kPrefixedApiLoadSessionHeader is uint8 array. So to use strlen I have to do a
cast. This code will be changed in a later CL. So I'll just keep it as is in
this CL.

+
+  if (init_data_length > kPrefixedApiLoadSessionHeaderLength &&
+      std::equal(init_data,
+                 init_data + kPrefixedApiLoadSessionHeaderLength,
+                 kPrefixedApiLoadSessionHeader)) {
+    // TODO(xhwang): Track loadable session to handle OnSessionClosed().
+    // See: http://crbug.com/340859.
+    media_keys_->LoadSession(
+        session_id,
+        std::string(reinterpret_cast<const char*>(
+                        init_data + kPrefixedApiLoadSessionHeaderLength),
+                    init_data_length - kPrefixedApiLoadSessionHeaderLength));
+    return true;
   }
 
-  return true;
+  return media_keys_->CreateSession(
+      session_id, content_type, init_data, init_data_length);
 }
 
 void ProxyDecryptor::AddKey(const uint8* key,
                             int key_length,
                             const uint8* init_data,
                             int init_data_length,
                             const std::string& web_session_id) {
   DVLOG(1) << "AddKey()";
 
   // WebMediaPlayerImpl ensures GenerateKeyRequest() has been called.
@@ skipping 100 matching lines @@
   // No closed event in EME v0.1b.
 }
 
 void ProxyDecryptor::OnSessionError(uint32 session_id,
                                     media::MediaKeys::KeyError error_code,
                                     int system_code) {
   // Assumes that OnSessionCreated() has been called before this.
   key_error_cb_.Run(LookupWebSessionId(session_id), error_code, system_code);
 }
 
 uint32 ProxyDecryptor::LookupSessionId(const std::string& session_id) {

[dcheng, 2014/02/11 23:12:25]

Minor unrelated nit: I think both of these functions can be const if iterator is
changed to const_iterator below.

[xhwang, 2014/02/12 02:22:45]

Done.

   for (SessionIdMap::iterator it = sessions_.begin();
        it != sessions_.end();
        ++it) {
     if (it->second == session_id)
       return it->first;
   }
 
   // If |session_id| is null, then use the single reference id.
   if (session_id.empty() && sessions_.size() == 1)
     return sessions_.begin()->first;
 
   return kInvalidSessionId;
 }
 
 const std::string& ProxyDecryptor::LookupWebSessionId(uint32 session_id) {
   DCHECK_NE(session_id, kInvalidSessionId);
 
   // Session may not exist if error happens during GenerateKeyRequest().
   SessionIdMap::iterator it = sessions_.find(session_id);
   return (it != sessions_.end()) ? it->second : base::EmptyString();
 }
 
 }  // namespace content