media: Separate renewal from default External Clear Key test

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 44 matching lines @@
 static bool g_ffmpeg_lib_initialized = InitializeFFmpegLibraries();
 
 #endif  // CLEAR_KEY_CDM_USE_FFMPEG_DECODER
 
 const char kClearKeyCdmVersion[] = "0.1.0.1";
 const char kExternalClearKeyKeySystem[] = "org.chromium.externalclearkey";
 
 // Variants of External Clear Key key system to test different scenarios.
 const char kExternalClearKeyDecryptOnlyKeySystem[] =
     "org.chromium.externalclearkey.decryptonly";
+const char kExternalClearKeyRenewalKeySystem[] =
+    "org.chromium.externalclearkey.renewal";
 const char kExternalClearKeyFileIOTestKeySystem[] =
     "org.chromium.externalclearkey.fileiotest";
 const char kExternalClearKeyOutputProtectionTestKeySystem[] =
     "org.chromium.externalclearkey.outputprotectiontest";
 const char kExternalClearKeyCrashKeySystem[] =
     "org.chromium.externalclearkey.crash";
 
 // Constants for the enumalted session that can be loaded by LoadSession().
 // These constants need to be in sync with
 // chrome/test/data/media/encrypted_media_utils.js
 const char kLoadableSessionId[] = "LoadableSession";
 const uint8_t kLoadableSessionKeyId[] = "0123456789012345";
 const uint8_t kLoadableSessionKey[] = {0xeb, 0xdd, 0x62, 0xf1, 0x68, 0x14,
                                        0xd2, 0x7b, 0x68, 0xef, 0x12, 0x2a,
                                        0xfc, 0xe4, 0xae, 0x3c};
 
 const int64_t kSecondsPerMinute = 60;
 const int64_t kMsPerSecond = 1000;
 const int64_t kInitialTimerDelayMs = 200;
 const int64_t kMaxTimerDelayMs = 1 * kSecondsPerMinute * kMsPerSecond;
-// Renewal message header. For prefixed EME, if a key message starts with
-// |kRenewalHeader|, it's a renewal message. Otherwise, it's a key request.
-// FIXME(jrummell): Remove this once prefixed EME goes away.
-const char kRenewalHeader[] = "RENEWAL";
 
 // CDM unit test result header. Must be in sync with UNIT_TEST_RESULT_HEADER in
 // media/test/data/eme_player_js/globals.js.
 const char kUnitTestResultHeader[] = "UNIT_TEST_RESULT";
 
 // Copies |input_buffer| into a media::DecoderBuffer. If the |input_buffer| is
 // empty, an empty (end-of-stream) media::DecoderBuffer is returned.
 static scoped_refptr<media::DecoderBuffer> CopyDecoderBufferFrom(
     const cdm::InputBuffer& input_buffer) {
   if (!input_buffer.data) {
@@ skipping 131 matching lines @@
 
 void* CreateCdmInstance(int cdm_interface_version,
                         const char* key_system, uint32_t key_system_size,
                         GetCdmHostFunc get_cdm_host_func,
                         void* user_data) {
   DVLOG(1) << "CreateCdmInstance()";
 
   std::string key_system_string(key_system, key_system_size);
   if (key_system_string != kExternalClearKeyKeySystem &&
       key_system_string != kExternalClearKeyDecryptOnlyKeySystem &&
+      key_system_string != kExternalClearKeyRenewalKeySystem &&
       key_system_string != kExternalClearKeyFileIOTestKeySystem &&
       key_system_string != kExternalClearKeyOutputProtectionTestKeySystem &&
       key_system_string != kExternalClearKeyCrashKeySystem) {
     DVLOG(1) << "Unsupported key system:" << key_system_string;
     return NULL;
   }
 
   if (cdm_interface_version != media::ClearKeyCdmInterface::kVersion)
     return NULL;
 
@@ skipping 121 matching lines @@
   std::unique_ptr<media::SimpleCdmPromise> promise(
       new media::CdmCallbackPromise<>(
           base::Bind(&ClearKeyCdm::OnPromiseResolved, base::Unretained(this),
                      promise_id),
           base::Bind(&ClearKeyCdm::OnPromiseFailed, base::Unretained(this),
                      promise_id)));
   decryptor_->UpdateSession(
       web_session_str, std::vector<uint8_t>(response, response + response_size),
       std::move(promise));
 
-  if (!renewal_timer_set_) {
+  if (key_system_ == kExternalClearKeyRenewalKeySystem && !renewal_timer_set_) {
     ScheduleNextRenewal();
     renewal_timer_set_ = true;
   }
 }
 
 void ClearKeyCdm::CloseSession(uint32_t promise_id,
                                const char* session_id,
                                uint32_t session_id_length) {
   DVLOG(1) << __FUNCTION__;
   std::string web_session_str(session_id, session_id_length);
@@ skipping 260 matching lines @@
 }
 
 void ClearKeyCdm::Destroy() {
   DVLOG(1) << "Destroy()";
   delete this;
 }
 
 void ClearKeyCdm::ScheduleNextRenewal() {
   // Prepare the next renewal message and set timer.
   std::ostringstream msg_stream;
-  msg_stream << kRenewalHeader << " from ClearKey CDM set at time "
+  msg_stream << "Renewal from ClearKey CDM set at time "
              << host_->GetCurrentWallTime() << ".";
   next_renewal_message_ = msg_stream.str();
 
   host_->SetTimer(timer_delay_ms_, &next_renewal_message_[0]);
 
   // Use a smaller timer delay at start-up to facilitate testing. Increase the
   // timer delay up to a limit to avoid message spam.
   if (timer_delay_ms_ < kMaxTimerDelayMs)
     timer_delay_ms_ = std::min(2 * timer_delay_ms_, kMaxTimerDelayMs);
 }
@@ skipping 283 matching lines @@
   OnUnitTestComplete(success);
   file_io_test_runner_.reset();
 }
 
 void ClearKeyCdm::StartOutputProtectionTest() {
   is_running_output_protection_test_ = true;
   host_->QueryOutputProtectionStatus();
 }
 
 }  // namespace media