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

media/cdm/cdm_adapter.cc

 // Copyright 2015 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/cdm_adapter.h"
 
 #include <stddef.h>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 319 matching lines @@
 
 // static
 void CdmAdapter::Create(
     const std::string& key_system,
     const base::FilePath& cdm_path,
     const CdmConfig& cdm_config,
     std::unique_ptr<CdmAllocator> allocator,
     const CreateCdmFileIOCB& create_cdm_file_io_cb,
     const SessionMessageCB& session_message_cb,
     const SessionClosedCB& session_closed_cb,
-    const LegacySessionErrorCB& legacy_session_error_cb,
     const SessionKeysChangeCB& session_keys_change_cb,
     const SessionExpirationUpdateCB& session_expiration_update_cb,
     const CdmCreatedCB& cdm_created_cb) {
   DCHECK(!key_system.empty());
   DCHECK(!session_message_cb.is_null());
   DCHECK(!session_closed_cb.is_null());
-  DCHECK(!legacy_session_error_cb.is_null());
   DCHECK(!session_keys_change_cb.is_null());
   DCHECK(!session_expiration_update_cb.is_null());
 
   scoped_refptr<CdmAdapter> cdm = new CdmAdapter(
       key_system, cdm_config, std::move(allocator), create_cdm_file_io_cb,
-      session_message_cb, session_closed_cb, legacy_session_error_cb,
-      session_keys_change_cb, session_expiration_update_cb);
+      session_message_cb, session_closed_cb, session_keys_change_cb,
+      session_expiration_update_cb);
 
   // |cdm| ownership passed to the promise.
   std::unique_ptr<CdmInitializedPromise> cdm_created_promise(
       new CdmInitializedPromise(cdm_created_cb, cdm));
 
   cdm->Initialize(cdm_path, std::move(cdm_created_promise));
 }
 
 CdmAdapter::CdmAdapter(
     const std::string& key_system,
     const CdmConfig& cdm_config,
     std::unique_ptr<CdmAllocator> allocator,
     const CreateCdmFileIOCB& create_cdm_file_io_cb,
     const SessionMessageCB& session_message_cb,
     const SessionClosedCB& session_closed_cb,
-    const LegacySessionErrorCB& legacy_session_error_cb,
     const SessionKeysChangeCB& session_keys_change_cb,
     const SessionExpirationUpdateCB& session_expiration_update_cb)
     : key_system_(key_system),
       cdm_config_(cdm_config),
       session_message_cb_(session_message_cb),
       session_closed_cb_(session_closed_cb),
-      legacy_session_error_cb_(legacy_session_error_cb),
       session_keys_change_cb_(session_keys_change_cb),
       session_expiration_update_cb_(session_expiration_update_cb),
       audio_samples_per_second_(0),
       audio_channel_layout_(CHANNEL_LAYOUT_NONE),
       allocator_(std::move(allocator)),
       create_cdm_file_io_cb_(create_cdm_file_io_cb),
       task_runner_(base::ThreadTaskRunnerHandle::Get()),
       weak_factory_(this) {
   DCHECK(!key_system_.empty());
   DCHECK(!session_message_cb_.is_null());
   DCHECK(!session_closed_cb_.is_null());
-  DCHECK(!legacy_session_error_cb_.is_null());
   DCHECK(!session_keys_change_cb_.is_null());
   DCHECK(!session_expiration_update_cb_.is_null());
   DCHECK(allocator_);
 }
 
 CdmAdapter::~CdmAdapter() {}
 
 CdmWrapper* CdmAdapter::CreateCdmInstance(const std::string& key_system,
                                           const base::FilePath& cdm_path) {
   DCHECK(task_runner_->BelongsToCurrentThread());
@@ skipping 365 matching lines @@
 }
 
 void CdmAdapter::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) {
   DCHECK(task_runner_->BelongsToCurrentThread());
-  DCHECK(legacy_destination_url_size == 0 ||
-         message_type != cdm::MessageType::kLicenseRequest);
-
-  GURL verified_gurl =
-      GURL(std::string(legacy_destination_url, legacy_destination_url_size));
-  if (!verified_gurl.is_valid()) {
-    DLOG(WARNING) << "SessionMessage legacy_destination_url is invalid : "
-                  << verified_gurl.possibly_invalid_spec();
-    verified_gurl = GURL::EmptyGURL();  // Replace invalid destination_url.
-  }
+  // |legacy_destination_url| is obsolete and will be removed as part of
+  // https://crbug.com/570216.
 
   const uint8_t* message_ptr = reinterpret_cast<const uint8_t*>(message);
   session_message_cb_.Run(
       std::string(session_id, session_id_size),
       ToMediaMessageType(message_type),
-      std::vector<uint8_t>(message_ptr, message_ptr + message_size),
-      verified_gurl);
+      std::vector<uint8_t>(message_ptr, message_ptr + message_size));
 }
 
 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) {
   DCHECK(task_runner_->BelongsToCurrentThread());
 
   CdmKeysInfo keys;
@@ skipping 34 matching lines @@
   session_closed_cb_.Run(std::string(session_id, session_id_size));
 }
 
 void CdmAdapter::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) {
   DCHECK(task_runner_->BelongsToCurrentThread());
-
-  legacy_session_error_cb_.Run(std::string(session_id, session_id_size),
-                               ToMediaExceptionType(error), system_code,
-                               std::string(error_message, error_message_size));
+  // Obsolete and will be removed as part of https://crbug.com/570216.
 }
 
 void CdmAdapter::SendPlatformChallenge(const char* service_id,
                                        uint32_t service_id_size,
                                        const char* challenge,
                                        uint32_t challenge_size) {
   DCHECK(task_runner_->BelongsToCurrentThread());
 
   // TODO(jrummell): If platform verification is available, use it.
   NOTIMPLEMENTED();
@@ skipping 99 matching lines @@
     result_frames->push_back(frame);
 
     data += frame_size;
     bytes_left -= frame_size;
   } while (bytes_left > 0);
 
   return true;
 }
 
 }  // namespace media