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

media/cdm/ppapi/external_clear_key/clear_key_cdm.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/external_clear_key/clear_key_cdm.h"
 
 #include <algorithm>
 #include <cstring>
 #include <sstream>
 #include <utility>
@@ skipping 235 matching lines @@
 
   if (cdm_interface_version != media::ClearKeyCdmInterface::kVersion)
     return NULL;
 
   media::ClearKeyCdmHost* host = static_cast<media::ClearKeyCdmHost*>(
       get_cdm_host_func(media::ClearKeyCdmHost::kVersion, user_data));
   if (!host)
     return NULL;
 
   // TODO(jrummell): Obtain the proper origin for this instance.
-  GURL empty_gurl;
-  return new media::ClearKeyCdm(host, key_system_string, empty_gurl);
+  GURL empty_origin;

[dcheng, 2016/08/19 18:38:59]

GURLs aren't origins =)

[ddorwin, 2016/08/19 18:54:16]

Just being consistent with the TODO and constructor parameter. :)
Last I knew, we don't have a SecurityOrigin object like on the Blink side. If we
do, we should switch the types.

[dcheng, 2016/08/19 18:56:14]

Actually, we do now: url::Origin. To be clear though, I don't expect any changes
WRT url::Origin for this CL, since it's obviously out of scope.

+  return new media::ClearKeyCdm(host, key_system_string, empty_origin);
 }
 
 const char* GetCdmVersion() {
   return kClearKeyCdmVersion;
 }
 
 namespace media {
 
 ClearKeyCdm::ClearKeyCdm(ClearKeyCdmHost* host,
                          const std::string& key_system,
@@ skipping 189 matching lines @@
 
   DCHECK(renewal_timer_set_);
   std::string renewal_message;
   if (!next_renewal_message_.empty() &&
       context == &next_renewal_message_[0]) {
     renewal_message = next_renewal_message_;
   } else {
     renewal_message = "ERROR: Invalid timer context found!";
   }
 
-  // This URL is only used for testing the code path for defaultURL.
-  // There is no service at this URL, so applications should ignore it.
-  const char url[] = "http://test.externalclearkey.chromium.org";
-
   host_->OnSessionMessage(last_session_id_.data(), last_session_id_.length(),
                           cdm::kLicenseRenewal, renewal_message.data(),
-                          renewal_message.length(), url, arraysize(url) - 1);
+                          renewal_message.length(), nullptr, 0);
 
   ScheduleNextRenewal();
 }
 
 static void CopyDecryptResults(
     media::Decryptor::Status* status_copy,
     scoped_refptr<media::DecoderBuffer>* buffer_copy,
     media::Decryptor::Status status,
     const scoped_refptr<media::DecoderBuffer>& buffer) {
   *status_copy = status;
@@ skipping 258 matching lines @@
                      base::Unretained(this)),
           base::Bind(&ClearKeyCdm::OnPromiseFailed, base::Unretained(this),
                      promise_id_for_emulated_loadsession_)));
   decryptor_->UpdateSession(
       session_id_for_emulated_loadsession_,
       std::vector<uint8_t>(jwk_set.begin(), jwk_set.end()), std::move(promise));
 }
 
 void ClearKeyCdm::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(1) << "OnSessionMessage: " << message.size();
 
   // Ignore the message when we are waiting to update the loadable session.
   if (session_id == session_id_for_emulated_loadsession_)
     return;
 
   // OnSessionMessage() only called during CreateSession(), so no promise
   // involved (OnSessionCreated() called to resolve the CreateSession()
   // promise).
   host_->OnSessionMessage(session_id.data(), session_id.length(),
                           cdm::kLicenseRequest,
                           reinterpret_cast<const char*>(message.data()),
-                          message.size(), legacy_destination_url.spec().data(),
-                          legacy_destination_url.spec().size());
+                          message.size(), nullptr, 0);
 }
 
 void ClearKeyCdm::OnSessionKeysChange(const std::string& session_id,
                                       bool has_additional_usable_key,
                                       CdmKeysInfo keys_info) {
   DVLOG(1) << "OnSessionKeysChange: " << keys_info.size();
 
   std::string new_session_id = session_id;
   if (new_session_id == session_id_for_emulated_loadsession_) {
     // Save |keys_info| if the loadable session is still being created. This
@@ skipping 156 matching lines @@
   total_samples_generated_ += samples_generated;
 
   return samples_generated == 0 ? cdm::kNeedMoreData : cdm::kSuccess;
 }
 #endif  // CLEAR_KEY_CDM_USE_FAKE_AUDIO_DECODER
 
 void ClearKeyCdm::OnUnitTestComplete(bool success) {
   std::string message = GetUnitTestResultMessage(success);
   host_->OnSessionMessage(last_session_id_.data(), last_session_id_.length(),
                           cdm::kLicenseRequest, message.data(),
-                          message.length(), NULL, 0);
+                          message.length(), nullptr, 0);
 }
 
 void ClearKeyCdm::StartFileIOTest() {
   file_io_test_runner_.reset(new FileIOTestRunner(
       base::Bind(&ClearKeyCdmHost::CreateFileIO, base::Unretained(host_))));
   file_io_test_runner_->RunAllTests(
       base::Bind(&ClearKeyCdm::OnFileIOTestComplete, base::Unretained(this)));
 }
 
 void ClearKeyCdm::OnFileIOTestComplete(bool success) {
   DVLOG(1) << __FUNCTION__ << ": " << success;
   OnUnitTestComplete(success);
   file_io_test_runner_.reset();
 }
 
 void ClearKeyCdm::StartOutputProtectionTest() {
   is_running_output_protection_test_ = true;
   host_->QueryOutputProtectionStatus();
 }
 
 }  // namespace media