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

media/mojo/clients/mojo_cdm.cc

 // Copyright 2014 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/mojo/clients/mojo_cdm.h"
 
 #include <stddef.h>
 
 #include <utility>
 
@@ skipping 22 matching lines @@
 }
 
 // static
 void MojoCdm::Create(
     const std::string& key_system,
     const GURL& security_origin,
     const media::CdmConfig& cdm_config,
     mojom::ContentDecryptionModulePtr remote_cdm,
     const media::SessionMessageCB& session_message_cb,
     const media::SessionClosedCB& session_closed_cb,
-    const media::LegacySessionErrorCB& legacy_session_error_cb,
     const media::SessionKeysChangeCB& session_keys_change_cb,
     const media::SessionExpirationUpdateCB& session_expiration_update_cb,
     const media::CdmCreatedCB& cdm_created_cb) {
   scoped_refptr<MojoCdm> mojo_cdm(
       new MojoCdm(std::move(remote_cdm), session_message_cb, session_closed_cb,
-                  legacy_session_error_cb, session_keys_change_cb,
-                  session_expiration_update_cb));
+                  session_keys_change_cb, session_expiration_update_cb));
 
   // |mojo_cdm| ownership is passed to the promise.
   std::unique_ptr<CdmInitializedPromise> promise(
       new CdmInitializedPromise(cdm_created_cb, mojo_cdm));
 
   mojo_cdm->InitializeCdm(key_system, security_origin, cdm_config,
                           std::move(promise));
 }
 
 MojoCdm::MojoCdm(mojom::ContentDecryptionModulePtr remote_cdm,
                  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)
     : remote_cdm_(std::move(remote_cdm)),
       binding_(this),
       cdm_id_(CdmContext::kInvalidCdmId),
       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),
       weak_factory_(this) {
   DVLOG(1) << __FUNCTION__;
   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());
 
   remote_cdm_->SetClient(binding_.CreateInterfacePtrAndBind());
 }
 
 MojoCdm::~MojoCdm() {
   DVLOG(1) << __FUNCTION__;
   DCHECK(thread_checker_.CalledOnValidThread());
 
@@ skipping 145 matching lines @@
 
 int MojoCdm::GetCdmId() const {
   base::AutoLock auto_lock(lock_);
   // Can be called on a different thread.
   DCHECK_NE(CdmContext::kInvalidCdmId, cdm_id_);
   return cdm_id_;
 }
 
 void MojoCdm::OnSessionMessage(const mojo::String& session_id,
                                mojom::CdmMessageType message_type,
-                               mojo::Array<uint8_t> message,
-                               const GURL& legacy_destination_url) {
+                               mojo::Array<uint8_t> message) {
   DVLOG(2) << __FUNCTION__;
   DCHECK(thread_checker_.CalledOnValidThread());
 
   session_message_cb_.Run(session_id,
                           static_cast<MediaKeys::MessageType>(message_type),
-                          message.storage(), legacy_destination_url);
+                          message.storage());
 }
 
 void MojoCdm::OnSessionClosed(const mojo::String& session_id) {
   DVLOG(2) << __FUNCTION__;
   DCHECK(thread_checker_.CalledOnValidThread());
 
   session_closed_cb_.Run(session_id);
 }
 
-void MojoCdm::OnLegacySessionError(const mojo::String& session_id,
-                                   mojom::CdmException exception,
-                                   uint32_t system_code,
-                                   const mojo::String& error_message) {
-  DVLOG(2) << __FUNCTION__;
-  DCHECK(thread_checker_.CalledOnValidThread());
-
-  legacy_session_error_cb_.Run(session_id,
-                               static_cast<MediaKeys::Exception>(exception),
-                               system_code, error_message);
-}
-
 void MojoCdm::OnSessionKeysChange(
     const mojo::String& session_id,
     bool has_additional_usable_key,
     mojo::Array<mojom::CdmKeyInformationPtr> keys_info) {
   DVLOG(2) << __FUNCTION__;
   DCHECK(thread_checker_.CalledOnValidThread());
 
   // TODO(jrummell): Handling resume playback should be done in the media
   // player, not in the Decryptors. http://crbug.com/413413.
   if (has_additional_usable_key) {
@@ skipping 52 matching lines @@
   base::AutoLock auto_lock(lock_);
 
   DCHECK(decryptor_task_runner_);
   DCHECK(decryptor_task_runner_->BelongsToCurrentThread());
   DCHECK(decryptor_);
 
   decryptor_->OnKeyAdded();
 }
 
 }  // namespace media