Support LoadSession() in MediaKeys and PPP_ContentDecryptor_Private interface.

media/cdm/ppapi/cdm_wrapper.h

 // 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.
 
 #ifndef MEDIA_CDM_PPAPI_CDM_WRAPPER_H_
 #define MEDIA_CDM_PPAPI_CDM_WRAPPER_H_
 
 #include <map>
 #include <queue>
 #include <string>
@@ skipping 34 matching lines @@
     CALL_KEY_ERROR
   };
 
   static CdmWrapper* Create(const char* key_system,
                             uint32_t key_system_size,
                             GetCdmHostFunc get_cdm_host_func,
                             void* user_data);
 
   virtual ~CdmWrapper() {};
 
+  // The CDM interface version this CDM implements.

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

This probably shouldn't be exposed. I think a temporary bool (or even
IsLoadSessionSupported() would be better.

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

Done.

+  virtual int GetCdmVersion() = 0;
+
   virtual void CreateSession(uint32_t session_id,
-                             const char* type,
-                             uint32_t type_size,
+                             const char* content_type,
+                             uint32_t content_type_size,
                              const uint8_t* init_data,
                              uint32_t init_data_size) = 0;
+  virtual void LoadSession(uint32_t session_id,
+                           const char* web_session_id,
+                           uint32_t web_session_id_size) = 0;
   virtual Result UpdateSession(uint32_t session_id,
                                const uint8_t* response,
                                uint32_t response_size) = 0;
   virtual Result ReleaseSession(uint32_t session_id) = 0;
   virtual void TimerExpired(void* context) = 0;
   virtual cdm::Status Decrypt(const cdm::InputBuffer& encrypted_buffer,
                               cdm::DecryptedBlock* decrypted_buffer) = 0;
   virtual cdm::Status InitializeAudioDecoder(
       const cdm::AudioDecoderConfig& audio_decoder_config) = 0;
   virtual cdm::Status InitializeVideoDecoder(
@@ skipping 70 matching lines @@
       return NULL;
 
     return new CdmWrapperImpl<CdmInterface>(
         static_cast<CdmInterface*>(cdm_instance));
   }
 
   virtual ~CdmWrapperImpl() {
     cdm_->Destroy();
   }
 
+  virtual int GetCdmVersion() OVERRIDE { return CdmInterface::kVersion; }
+
   virtual void CreateSession(uint32_t session_id,
-                             const char* type,
-                             uint32_t type_size,
+                             const char* content_type,
+                             uint32_t content_type_size,
                              const uint8_t* init_data,
                              uint32_t init_data_size) OVERRIDE {
-    // TODO(xhwang): Update the full MediaKeys stack to support LoadSession.
-    // See: http://crbug.com/338831
-    const uint8_t kPrefixedApiLoadSessionHeader[] = "LOAD_SESSION|";
-    const size_t kPrefixedApiLoadSessionHeaderSize =
-        sizeof(kPrefixedApiLoadSessionHeader) - 1;
+    cdm_->CreateSession(
+        session_id, content_type, content_type_size, init_data, init_data_size);
+  }
 
-    if (init_data_size > kPrefixedApiLoadSessionHeaderSize &&
-        std::equal(init_data,
-                   init_data + kPrefixedApiLoadSessionHeaderSize,
-                   kPrefixedApiLoadSessionHeader)) {
-      cdm_->LoadSession(session_id,
-                        reinterpret_cast<const char*>(
-                            init_data + kPrefixedApiLoadSessionHeaderSize),
-                        init_data_size - kPrefixedApiLoadSessionHeaderSize);
-      return;
-    }
-
-    cdm_->CreateSession(session_id, type, type_size, init_data, init_data_size);
+  virtual void LoadSession(uint32_t session_id,
+                           const char* web_session_id,
+                           uint32_t web_session_id_size) OVERRIDE {
+    cdm_->LoadSession(session_id, web_session_id, web_session_id_size);
   }
 
   virtual Result UpdateSession(uint32_t session_id,
                                const uint8_t* response,
                                uint32_t response_size) OVERRIDE {
     cdm_->UpdateSession(session_id, response, response_size);
     return NO_ACTION;
   }
 
   virtual Result ReleaseSession(uint32_t session_id) OVERRIDE {
@@ skipping 78 matching lines @@
     // string from using the wrong session_id.
     if (!web_session_id.empty()) {
       PP_DCHECK(session_map_.find(session_id) == session_map_.end());
       session_map_[session_id] = web_session_id;
     }
 
     return session_id;
   }
 
   const std::string LookupWebSessionId(uint32_t session_id) {
-    // Session may not exist if error happens during CreateSession().
+    // Session may not exist if error happens during CreateSession() or
+    // LoadSession().
     SessionMap::iterator it = session_map_.find(session_id);
     return (it != session_map_.end()) ? it->second : std::string();
   }
 
  private:
   CdmWrapperImpl(CdmInterface* cdm) : cdm_(cdm) {
     PP_DCHECK(cdm_);
   }
 
   CdmInterface* cdm_;
 
   DISALLOW_COPY_AND_ASSIGN(CdmWrapperImpl);
 };
 
 // For ContentDecryptionModule_1 and ContentDecryptionModule_2,
-// CreateSession(), UpdateSession(), and ReleaseSession() call methods
-// are incompatible with ContentDecryptionModule_4. Use the following
+// CreateSession(), LoadSession(), UpdateSession(), and ReleaseSession() call
+// methods are incompatible with ContentDecryptionModule_4. Use the following
 // templated functions to handle this.
 
 template <class CdmInterface>
 void PrefixedGenerateKeyRequest(CdmWrapper* wrapper,
                                 CdmInterface* cdm,
                                 uint32_t session_id,
-                                const char* type,
-                                uint32_t type_size,
+                                const char* content_type,
+                                uint32_t content_type_size,
                                 const uint8_t* init_data,
                                 uint32_t init_data_size) {
   // As it is possible for CDMs to reply synchronously during the call to
   // GenerateKeyRequest(), keep track of |session_id|.
   wrapper->current_key_request_session_id_ = session_id;
 
-  cdm::Status status =
-      cdm->GenerateKeyRequest(type, type_size, init_data, init_data_size);
+  cdm::Status status = cdm->GenerateKeyRequest(
+      content_type, content_type_size, init_data, init_data_size);
   PP_DCHECK(status == cdm::kSuccess || status == cdm::kSessionError);
   if (status != cdm::kSuccess) {
     // If GenerateKeyRequest() failed, no subsequent asynchronous replies
     // will be sent. Verify that a response was sent synchronously.
     PP_DCHECK(wrapper->current_key_request_session_id_ ==
               CdmWrapper::kInvalidSessionId);
     wrapper->current_key_request_session_id_ = CdmWrapper::kInvalidSessionId;
     return;
   }
 
@@ skipping 56 matching lines @@
   }
 
   return CdmWrapper::NO_ACTION;
 }
 
 // Specializations for ContentDecryptionModule_1.
 
 template <>
 void CdmWrapperImpl<cdm::ContentDecryptionModule_1>::CreateSession(
     uint32_t session_id,
-    const char* type,
-    uint32_t type_size,
+    const char* content_type,
+    uint32_t content_type_size,
     const uint8_t* init_data,
     uint32_t init_data_size) {
-  PrefixedGenerateKeyRequest(
-      this, cdm_, session_id, type, type_size, init_data, init_data_size);
+  PrefixedGenerateKeyRequest(this,
+                             cdm_,
+                             session_id,
+                             content_type,
+                             content_type_size,
+                             init_data,
+                             init_data_size);
 }
 
 template <>
+void CdmWrapperImpl<cdm::ContentDecryptionModule_1>::LoadSession(
+    uint32_t session_id,
+    const char* web_session_id,
+    uint32_t web_session_id_size) {
+  PP_NOTREACHED();
+}
+
+template <>
 CdmWrapper::Result CdmWrapperImpl<
     cdm::ContentDecryptionModule_1>::UpdateSession(uint32_t session_id,
                                                    const uint8_t* response,
                                                    uint32_t response_size) {
   return PrefixedAddKey(this, cdm_, session_id, response, response_size);
 }
 
 template <>
 CdmWrapper::Result CdmWrapperImpl<
     cdm::ContentDecryptionModule_1>::ReleaseSession(uint32_t session_id) {
@@ skipping 24 matching lines @@
   audio_frames->SetFrameBuffer(audio_frames_1.PassFrameBuffer());
   audio_frames->SetFormat(cdm::kAudioFormatS16);
   return cdm::kSuccess;
 }
 
 // Specializations for ContentDecryptionModule_2.
 
 template <>
 void CdmWrapperImpl<cdm::ContentDecryptionModule_2>::CreateSession(
     uint32_t session_id,
-    const char* type,
-    uint32_t type_size,
+    const char* content_type,
+    uint32_t content_type_size,
     const uint8_t* init_data,
     uint32_t init_data_size) {
-  PrefixedGenerateKeyRequest(
-      this, cdm_, session_id, type, type_size, init_data, init_data_size);
+  PrefixedGenerateKeyRequest(this,
+                             cdm_,
+                             session_id,
+                             content_type,
+                             content_type_size,
+                             init_data,
+                             init_data_size);
 }
 
 template <>
+void CdmWrapperImpl<cdm::ContentDecryptionModule_2>::LoadSession(
+    uint32_t session_id,
+    const char* web_session_id,
+    uint32_t web_session_id_size) {
+  PP_NOTREACHED();
+}
+
+template <>
 CdmWrapper::Result CdmWrapperImpl<
     cdm::ContentDecryptionModule_2>::UpdateSession(uint32_t session_id,
                                                    const uint8_t* response,
                                                    uint32_t response_size) {
   return PrefixedAddKey(this, cdm_, session_id, response, response_size);
 }
 
 template <>
 CdmWrapper::Result CdmWrapperImpl<
     cdm::ContentDecryptionModule_2>::ReleaseSession(uint32_t session_id) {
@@ skipping 45 matching lines @@
 // stub implementations for new or modified methods that the older CDM interface
 // does not have.
 // Also update supported_cdm_versions.h.
 COMPILE_ASSERT(cdm::ContentDecryptionModule::kVersion ==
                    cdm::ContentDecryptionModule_4::kVersion,
                ensure_cdm_wrapper_templates_have_old_version_support);
 
 }  // namespace media
 
 #endif  // MEDIA_CDM_PPAPI_CDM_WRAPPER_H_