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

content/renderer/media/cdm/ppapi_decryptor.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 "content/renderer/media/cdm/ppapi_decryptor.h"
 
 #include <string>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 16 matching lines @@
 namespace content {
 
 void PpapiDecryptor::Create(
     const std::string& key_system,
     const GURL& security_origin,
     bool allow_distinctive_identifier,
     bool allow_persistent_state,
     const CreatePepperCdmCB& create_pepper_cdm_cb,
     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) {
   std::string plugin_type = media::GetPepperType(key_system);
   DCHECK(!plugin_type.empty());
 
   std::unique_ptr<PepperCdmWrapper> pepper_cdm_wrapper;
   {
     TRACE_EVENT0("media", "PpapiDecryptor::CreatePepperCDM");
     pepper_cdm_wrapper = create_pepper_cdm_cb.Run(plugin_type, security_origin);
   }
 
   if (!pepper_cdm_wrapper) {
     std::string message =
         "Unable to create the CDM for the key system " + key_system + ".";
     DLOG(ERROR) << message;
     base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE, base::Bind(cdm_created_cb, nullptr, message));
     return;
   }
 
-  scoped_refptr<PpapiDecryptor> ppapi_decryptor(
-      new PpapiDecryptor(std::move(pepper_cdm_wrapper), session_message_cb,
-                         session_closed_cb, legacy_session_error_cb,
-                         session_keys_change_cb, session_expiration_update_cb));
+  scoped_refptr<PpapiDecryptor> ppapi_decryptor(new PpapiDecryptor(
+      std::move(pepper_cdm_wrapper), session_message_cb, session_closed_cb,
+      session_keys_change_cb, session_expiration_update_cb));
 
   // |ppapi_decryptor| ownership is passed to the promise.
   std::unique_ptr<media::CdmInitializedPromise> promise(
       new media::CdmInitializedPromise(cdm_created_cb, ppapi_decryptor));
 
   ppapi_decryptor->InitializeCdm(key_system, allow_distinctive_identifier,
                                  allow_persistent_state, std::move(promise));
 }
 
 PpapiDecryptor::PpapiDecryptor(
     std::unique_ptr<PepperCdmWrapper> pepper_cdm_wrapper,
     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)
     : pepper_cdm_wrapper_(std::move(pepper_cdm_wrapper)),
       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),
       render_task_runner_(base::ThreadTaskRunnerHandle::Get()),
       weak_ptr_factory_(this) {
   DCHECK(pepper_cdm_wrapper_.get());
   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());
 }
 
 PpapiDecryptor::~PpapiDecryptor() {
   pepper_cdm_wrapper_.reset();
 }
 
 void PpapiDecryptor::InitializeCdm(
     const std::string& key_system,
     bool allow_distinctive_identifier,
     bool allow_persistent_state,
     std::unique_ptr<media::SimpleCdmPromise> promise) {
   base::WeakPtr<PpapiDecryptor> weak_this = weak_ptr_factory_.GetWeakPtr();
   CdmDelegate()->Initialize(
       key_system, allow_distinctive_identifier, allow_persistent_state,
       base::Bind(&PpapiDecryptor::OnSessionMessage, weak_this),
       base::Bind(&PpapiDecryptor::OnSessionClosed, weak_this),
-      base::Bind(&PpapiDecryptor::OnLegacySessionError, weak_this),
       base::Bind(&PpapiDecryptor::OnSessionKeysChange, weak_this),
       base::Bind(&PpapiDecryptor::OnSessionExpirationUpdate, weak_this),
       base::Bind(&PpapiDecryptor::OnFatalPluginError, weak_this),
       std::move(promise));
 }
 
 void PpapiDecryptor::SetServerCertificate(
     const std::vector<uint8_t>& certificate,
     std::unique_ptr<media::SimpleCdmPromise> promise) {
   DVLOG(2) << __func__;
@@ skipping 269 matching lines @@
       DCHECK(!video_decoder_init_cb_.is_null());
       base::ResetAndReturn(&video_decoder_init_cb_).Run(success);
       break;
     default:
       NOTREACHED();
   }
 }
 
 void PpapiDecryptor::OnSessionMessage(const std::string& session_id,
                                       MessageType message_type,
-                                      const std::vector<uint8_t>& message,
-                                      const GURL& legacy_destination_url) {
+                                      const std::vector<uint8_t>& message) {
   DCHECK(render_task_runner_->BelongsToCurrentThread());
-  session_message_cb_.Run(session_id, message_type, message,
-                          legacy_destination_url);
+  session_message_cb_.Run(session_id, message_type, message);
 }
 
 void PpapiDecryptor::OnSessionKeysChange(const std::string& session_id,
                                          bool has_additional_usable_key,
                                          media::CdmKeysInfo keys_info) {
   DVLOG(2) << __func__ << ": " << has_additional_usable_key;
   DCHECK(render_task_runner_->BelongsToCurrentThread());
 
   // 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)
     AttemptToResumePlayback();
 
   session_keys_change_cb_.Run(session_id, has_additional_usable_key,
                               std::move(keys_info));
 }
 
 void PpapiDecryptor::OnSessionExpirationUpdate(
     const std::string& session_id,
     const base::Time& new_expiry_time) {
   DCHECK(render_task_runner_->BelongsToCurrentThread());
   session_expiration_update_cb_.Run(session_id, new_expiry_time);
 }
 
 void PpapiDecryptor::OnSessionClosed(const std::string& session_id) {
   DCHECK(render_task_runner_->BelongsToCurrentThread());
   session_closed_cb_.Run(session_id);
 }
 
-void PpapiDecryptor::OnLegacySessionError(
-    const std::string& session_id,
-    MediaKeys::Exception exception_code,
-    uint32_t system_code,
-    const std::string& error_description) {
-  DCHECK(render_task_runner_->BelongsToCurrentThread());
-  legacy_session_error_cb_.Run(session_id, exception_code, system_code,
-                               error_description);
-}
-
 void PpapiDecryptor::AttemptToResumePlayback() {
   if (!new_audio_key_cb_.is_null())
     new_audio_key_cb_.Run();
 
   if (!new_video_key_cb_.is_null())
     new_video_key_cb_.Run();
 }
 
 void PpapiDecryptor::OnFatalPluginError() {
   DCHECK(render_task_runner_->BelongsToCurrentThread());
   pepper_cdm_wrapper_.reset();
 }
 
 ContentDecryptorDelegate* PpapiDecryptor::CdmDelegate() {
   DCHECK(render_task_runner_->BelongsToCurrentThread());
   return (pepper_cdm_wrapper_) ? pepper_cdm_wrapper_->GetCdmDelegate() : NULL;
 }
 
 }  // namespace content