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

media/mojo/services/mojo_cdm_service.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/services/mojo_cdm_service.h"
 
 #include <map>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 98 matching lines @@
                                 mojom::CdmConfigPtr cdm_config,
                                 const InitializeCallback& callback) {
   DVLOG(1) << __FUNCTION__ << ": " << key_system;
   DCHECK(!cdm_);
 
   auto weak_this = weak_factory_.GetWeakPtr();
   cdm_factory_->Create(
       key_system, GURL(security_origin.get()), cdm_config.To<CdmConfig>(),
       base::Bind(&MojoCdmService::OnSessionMessage, weak_this),
       base::Bind(&MojoCdmService::OnSessionClosed, weak_this),
-      base::Bind(&MojoCdmService::OnLegacySessionError, weak_this),
       base::Bind(&MojoCdmService::OnSessionKeysChange, weak_this),
       base::Bind(&MojoCdmService::OnSessionExpirationUpdate, weak_this),
       base::Bind(&MojoCdmService::OnCdmCreated, weak_this, callback));
 }
 
 void MojoCdmService::SetServerCertificate(
     mojo::Array<uint8_t> certificate_data,
     const SetServerCertificateCallback& callback) {
   DVLOG(2) << __FUNCTION__;
   cdm_->SetServerCertificate(
@@ skipping 85 matching lines @@
   }
 
   DVLOG(1) << __FUNCTION__ << ": CDM successfully created with ID " << cdm_id_;
   cdm_promise_result->success = true;
   callback.Run(std::move(cdm_promise_result), cdm_id_,
                std::move(decryptor_service));
 }
 
 void MojoCdmService::OnSessionMessage(const std::string& session_id,
                                       MediaKeys::MessageType message_type,
-                                      const std::vector<uint8_t>& message,
-                                      const GURL& legacy_destination_url) {
+                                      const std::vector<uint8_t>& message) {
   DVLOG(2) << __FUNCTION__ << "(" << message_type << ")";
-  client_->OnSessionMessage(
-      session_id, static_cast<mojom::CdmMessageType>(message_type),
-      mojo::Array<uint8_t>::From(message), legacy_destination_url);
+  client_->OnSessionMessage(session_id,
+                            static_cast<mojom::CdmMessageType>(message_type),
+                            mojo::Array<uint8_t>::From(message));
 }
 
 void MojoCdmService::OnSessionKeysChange(const std::string& session_id,
                                          bool has_additional_usable_key,
                                          CdmKeysInfo keys_info) {
   DVLOG(2) << __FUNCTION__
            << " has_additional_usable_key=" << has_additional_usable_key;
 
   mojo::Array<mojom::CdmKeyInformationPtr> keys_data;
   for (auto* key : keys_info)
     keys_data.push_back(mojom::CdmKeyInformation::From(*key));
   client_->OnSessionKeysChange(session_id, has_additional_usable_key,
                                std::move(keys_data));
 }
 
 void MojoCdmService::OnSessionExpirationUpdate(
     const std::string& session_id,
     const base::Time& new_expiry_time_sec) {
   DVLOG(2) << __FUNCTION__ << " expiry=" << new_expiry_time_sec;
   client_->OnSessionExpirationUpdate(session_id,
                                      new_expiry_time_sec.ToDoubleT());
 }
 
 void MojoCdmService::OnSessionClosed(const std::string& session_id) {
   DVLOG(2) << __FUNCTION__;
   client_->OnSessionClosed(session_id);
 }
 
-void MojoCdmService::OnLegacySessionError(const std::string& session_id,
-                                          MediaKeys::Exception exception,
-                                          uint32_t system_code,
-                                          const std::string& error_message) {
-  DVLOG(2) << __FUNCTION__ << "(" << exception << ") " << error_message;
-  client_->OnLegacySessionError(session_id,
-                                static_cast<mojom::CdmException>(exception),
-                                system_code, error_message);
-}
-
 void MojoCdmService::OnDecryptorConnectionError() {
   DVLOG(2) << __FUNCTION__;
 
   // MojoDecryptorService has lost connectivity to it's client, so it can be
   // freed.
   decryptor_.reset();
 }
 
 }  // namespace media