Add |legacy_destination_url| back to SessionMessage for EME

media/cdm/ppapi/cdm_adapter.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/cdm_adapter.h"
 
 #include "media/base/limits.h"
 #include "media/cdm/ppapi/cdm_file_io_impl.h"
 #include "media/cdm/ppapi/cdm_helpers.h"
 #include "media/cdm/ppapi/cdm_logging.h"
@@ skipping 697 matching lines @@
       &CdmAdapter::SendPromiseRejectedInternal,
       promise_id,
       SessionError(error, system_code, error_message)));
 }
 
 // cdm::Host_7 only.
 void CdmAdapter::OnSessionMessage(const char* session_id,
                                   uint32_t session_id_size,
                                   cdm::MessageType message_type,
                                   const char* message,
-                                  uint32_t message_size) {
+                                  uint32_t message_size,
+                                  const char* legacy_destination_url,
+                                  uint32_t legacy_destination_url_size) {
+  // Only license renewals should specify |legacy_destination_url|.
+  // |legacy_destination_url| is not passed to unprefixed EME applications,
+  // so it can be removed when the prefixed API is removed.
+  PP_DCHECK(legacy_destination_url_size == 0 ||
+            message_type == cdm::MessageType::kLicenseRenewal);
+
   PostOnMain(callback_factory_.NewCallback(
       &CdmAdapter::SendSessionMessageInternal,
-      std::string(session_id, session_id_size), message_type,
-      std::vector<uint8_t>(message, message + message_size)));
+      SessionMessage(
+          std::string(session_id, session_id_size), message_type,
+          std::vector<uint8_t>(message, message + message_size),
+          std::string(legacy_destination_url, legacy_destination_url_size))));
 }
 
 // cdm::Host_6 only.
 void CdmAdapter::OnSessionMessage(const char* session_id,
                                   uint32_t session_id_size,
                                   const char* message,
                                   uint32_t message_size,
                                   const char* destination_url,
                                   uint32_t destination_url_size) {
-  // |destination_url| is no longer passed to EME applications, so it is
-  // dropped. All messages will appear as license renewals if |destination_url|
-  // is provided, license request if not.
+  // |destination_url| is no longer passed to unprefixed EME applications,
+  // so it will be dropped. All messages will appear as license renewals
+  // if |destination_url| is provided, license request if not.
   cdm::MessageType message_type = (destination_url_size > 0)
                                       ? cdm::MessageType::kLicenseRenewal
                                       : cdm::MessageType::kLicenseRequest;
   PostOnMain(callback_factory_.NewCallback(
       &CdmAdapter::SendSessionMessageInternal,
-      std::string(session_id, session_id_size), message_type,
-      std::vector<uint8_t>(message, message + message_size)));
+      SessionMessage(std::string(session_id, session_id_size), message_type,
+                     std::vector<uint8_t>(message, message + message_size),
+                     std::string(destination_url, destination_url_size))));
 }
 
 // cdm::Host_7 only.
 void CdmAdapter::OnSessionKeysChange(const char* session_id,
                                      uint32_t session_id_size,
                                      bool has_additional_usable_key,
                                      const cdm::KeyInformation* keys_info,
                                      uint32_t keys_info_count) {
   std::vector<PP_KeyInformation> key_information;
   for (uint32_t i = 0; i < keys_info_count; ++i) {
@@ skipping 92 matching lines @@
                                              uint32_t promise_id,
                                              const SessionError& error) {
   PP_DCHECK(result == PP_OK);
   pp::ContentDecryptor_Private::PromiseRejected(
       promise_id,
       CdmExceptionTypeToPpCdmExceptionType(error.error),
       error.system_code,
       error.error_description);
 }
 
-void CdmAdapter::SendSessionMessageInternal(
-    int32_t result,
-    const std::string& session_id,
-    cdm::MessageType message_type,
-    const std::vector<uint8_t>& message) {
+void CdmAdapter::SendSessionMessageInternal(int32_t result,
+                                            const SessionMessage& message) {
   PP_DCHECK(result == PP_OK);
 
-  pp::VarArrayBuffer message_array_buffer(message.size());
-  if (message.size() > 0) {
-    memcpy(message_array_buffer.Map(), message.data(), message.size());
+  pp::VarArrayBuffer message_array_buffer(message.message.size());
+  if (message.message.size() > 0) {
+    memcpy(message_array_buffer.Map(), message.message.data(),
+           message.message.size());
   }
 
   pp::ContentDecryptor_Private::SessionMessage(
-      session_id, CdmMessageTypeToPpMessageType(message_type),
-      message_array_buffer);
+      message.session_id, CdmMessageTypeToPpMessageType(message.message_type),
+      message_array_buffer, message.legacy_destination_url);
 }
 
 void CdmAdapter::SendSessionClosedInternal(int32_t result,
                                            const std::string& session_id) {
   PP_DCHECK(result == PP_OK);
   pp::ContentDecryptor_Private::SessionClosed(session_id);
 }
 
 void CdmAdapter::SendSessionErrorInternal(int32_t result,
                                           const std::string& session_id,
@@ skipping 420 matching lines @@
 #endif
 
 CdmAdapter::SessionError::SessionError(cdm::Error error,
                                        uint32_t system_code,
                                        std::string error_description)
     : error(error),
       system_code(system_code),
       error_description(error_description) {
 }
 
+CdmAdapter::SessionMessage::SessionMessage(std::string session_id,
+                                           cdm::MessageType message_type,
+                                           std::vector<uint8_t> message,
+                                           std::string legacy_destination_url)
+    : session_id(session_id),
+      message_type(message_type),
+      message(message),
+      legacy_destination_url(legacy_destination_url) {
+}
+
 void* GetCdmHost(int host_interface_version, void* user_data) {
   if (!host_interface_version || !user_data)
     return NULL;
 
   static_assert(
       cdm::ContentDecryptionModule::Host::kVersion == cdm::Host_7::kVersion,
       "update the code below");
 
   // Ensure IsSupportedCdmHostVersion matches implementation of this function.
   // Always update this DCHECK when updating this function.
@@ skipping 48 matching lines @@
 }  // namespace media
 
 namespace pp {
 
 // Factory function for your specialization of the Module object.
 Module* CreateModule() {
   return new media::CdmAdapterModule();
 }
 
 }  // namespace pp