Support LoadSession() in MediaKeys and PPP_ContentDecryptor_Private interface.

content/renderer/media/android/proxy_media_keys.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/android/proxy_media_keys.h"
 
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/logging.h"
@@ skipping 29 matching lines @@
 #if defined(ENABLE_PEPPER_CDMS)
   NOTIMPLEMENTED();
 #elif defined(OS_ANDROID)
   std::vector<uint8> uuid = GetUUID(key_system);
   DCHECK(!uuid.empty());
   manager_->InitializeCDM(media_keys_id_, this, uuid, frame_url);
 #endif
 }
 
 bool ProxyMediaKeys::CreateSession(uint32 session_id,
-                                   const std::string& type,
+                                   const std::string& content_type,
                                    const uint8* init_data,
                                    int init_data_length) {
   MediaKeysHostMsg_CreateSession_Type session_type;
-  if (type == "audio/mp4" || type == "video/mp4") {
+  if (content_type == "audio/mp4" || content_type == "video/mp4") {

[ddorwin, 2014/02/10 19:05:25]

This should be checked elsewhere, which means we could DCHECK at line 59. Why
don't we have this in other implementations?

(See related comments in media_keys.h.)

[xhwang, 2014/02/10 22:30:55]

Added TODO.

     session_type = CREATE_SESSION_TYPE_MP4;
-  } else if (type == "audio/webm" || type == "video/webm") {
+  } else if (content_type == "audio/webm" || content_type == "video/webm") {
     session_type = CREATE_SESSION_TYPE_WEBM;
   } else {
-    DLOG(ERROR) << "Unsupported EME CreateSession type of " << type;
+    DLOG(ERROR) << "Unsupported EME CreateSession content type of "
+                << content_type;
     OnSessionError(session_id, media::MediaKeys::kUnknownError, 0);

[ddorwin, 2014/02/10 19:05:25]

I don't think we should be throwing this error.

[xhwang, 2014/02/10 22:30:55]

Done.

     return false;
   }
 
   manager_->CreateSession(
       media_keys_id_,
       session_id,
       session_type,
       std::vector<uint8>(init_data, init_data + init_data_length));
   return true;
 }
 
+bool ProxyMediaKeys::LoadSession(uint32 session_id,
+                                 const std::string& web_session_id) {
+  DLOG(ERROR) << "ProxyMediaKeys doesn't support session loading.";
+  OnSessionError(session_id, media::MediaKeys::kUnknownError, 0);
+  return false;
+}
+
 void ProxyMediaKeys::UpdateSession(uint32 session_id,
                                    const uint8* response,
                                    int response_length) {
   manager_->UpdateSession(
       media_keys_id_,
       session_id,
       std::vector<uint8>(response, response + response_length));
 }
 
 void ProxyMediaKeys::ReleaseSession(uint32 session_id) {
@@ skipping 19 matching lines @@
   session_closed_cb_.Run(session_id);
 }
 
 void ProxyMediaKeys::OnSessionError(uint32 session_id,
                                     media::MediaKeys::KeyError error_code,
                                     int system_code) {
   session_error_cb_.Run(session_id, error_code, system_code);
 }
 
 }  // namespace content