EME: Remove obsolete legacy APIs related to versions of prefixed EME

media/cdm/ppapi/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/ppapi_cdm_adapter.h"
 
 #include <string.h>
 
 #include "base/macros.h"
 #include "build/build_config.h"
@@ skipping 676 matching lines @@
       SessionError(error, system_code, error_message)));
 }
 
 void PpapiCdmAdapter::OnSessionMessage(const char* session_id,
                                        uint32_t session_id_size,
                                        cdm::MessageType message_type,
                                        const char* message,
                                        uint32_t message_size,
                                        const char* legacy_destination_url,
                                        uint32_t legacy_destination_url_size) {
+  // |legacy_destination_url| is obsolete and will be removed as part of
+  // https://crbug.com/570216.
   // License requests should not 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 ||

[jrummell, 2016/08/18 19:10:43]

Since we're not passing |legacy_destination_url| on, should this check be
removed?

[ddorwin, 2016/08/18 19:21:48]

This is an assumption about the input from CDMs. It's probably not necessary,
but if a CDM did something different, that might be a problem we'd want to know
about. That's unlikely, but since this does not affect production, I think it's
fine to leave it until the bug above is addressed.

             message_type != cdm::MessageType::kLicenseRequest);
 
   PostOnMain(callback_factory_.NewCallback(
       &PpapiCdmAdapter::SendSessionMessageInternal,
-      SessionMessage(
-          std::string(session_id, session_id_size), message_type, message,
-          message_size,
-          std::string(legacy_destination_url, legacy_destination_url_size))));
+      SessionMessage(std::string(session_id, session_id_size), message_type,
+                     message, message_size)));
 }
 
 void PpapiCdmAdapter::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) {
     const auto& key_info = keys_info[i];
@@ skipping 34 matching lines @@
       callback_factory_.NewCallback(&PpapiCdmAdapter::SendSessionClosedInternal,
                                     std::string(session_id, session_id_size)));
 }
 
 void PpapiCdmAdapter::OnLegacySessionError(const char* session_id,
                                            uint32_t session_id_size,
                                            cdm::Error error,
                                            uint32_t system_code,
                                            const char* error_message,
                                            uint32_t error_message_size) {
-  PostOnMain(callback_factory_.NewCallback(
-      &PpapiCdmAdapter::SendSessionErrorInternal,
-      std::string(session_id, session_id_size),
-      SessionError(error, system_code,
-                   std::string(error_message, error_message_size))));
+  // Obsolete and will be removed as part of https://crbug.com/570216.
 }
 
 // Helpers to pass the event to Pepper.
 
 void PpapiCdmAdapter::SendPromiseResolvedInternal(int32_t result,
                                                   uint32_t promise_id) {
   PP_DCHECK(result == PP_OK);
   pp::ContentDecryptor_Private::PromiseResolved(promise_id);
 }
 
@@ skipping 21 matching lines @@
   PP_DCHECK(result == PP_OK);
 
   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(
       message.session_id, CdmMessageTypeToPpMessageType(message.message_type),
-      message_array_buffer, message.legacy_destination_url);
+      message_array_buffer, std::string());
 }
 
 void PpapiCdmAdapter::SendSessionClosedInternal(int32_t result,
                                                 const std::string& session_id) {
   PP_DCHECK(result == PP_OK);
   pp::ContentDecryptor_Private::SessionClosed(session_id);
 }
 
-void PpapiCdmAdapter::SendSessionErrorInternal(int32_t result,
-                                               const std::string& session_id,
-                                               const SessionError& error) {
-  PP_DCHECK(result == PP_OK);
-  pp::ContentDecryptor_Private::LegacySessionError(
-      session_id, CdmExceptionTypeToPpCdmExceptionType(error.error),
-      error.system_code, error.error_description);
-}
-
 void PpapiCdmAdapter::SendSessionKeysChangeInternal(
     int32_t result,
     const std::string& session_id,
     bool has_additional_usable_key,
     const std::vector<PP_KeyInformation>& key_info) {
   PP_DCHECK(result == PP_OK);
   pp::ContentDecryptor_Private::SessionKeysChange(
       session_id, has_additional_usable_key, key_info);
 }
 
@@ skipping 399 matching lines @@
 }
 
 PpapiCdmAdapter::SessionError::SessionError(
     cdm::Error error,
     uint32_t system_code,
     const std::string& error_description)
     : error(error),
       system_code(system_code),
       error_description(error_description) {}
 
-PpapiCdmAdapter::SessionMessage::SessionMessage(
-    const std::string& session_id,
-    cdm::MessageType message_type,
-    const char* message,
-    uint32_t message_size,
-    const std::string& legacy_destination_url)
+PpapiCdmAdapter::SessionMessage::SessionMessage(const std::string& session_id,
+                                                cdm::MessageType message_type,
+                                                const char* message,
+                                                uint32_t message_size)
     : session_id(session_id),
       message_type(message_type),
-      message(message, message + message_size),
-      legacy_destination_url(legacy_destination_url) {}
+      message(message, message + message_size) {}
 
 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_8::kVersion,
       "update the code below");
 
   // Ensure IsSupportedCdmHostVersion matches implementation of this function.
@@ skipping 47 matching lines @@
 }  // namespace media
 
 namespace pp {
 
 // Factory function for your specialization of the Module object.
 Module* CreateModule() {
   return new media::PpapiCdmAdapterModule();
 }
 
 }  // namespace pp