Add decrypt-only external clear key browser tests.

media/cdm/ppapi/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/clear_key_cdm.h"
 
 #include <algorithm>
 #include <sstream>
 #include <string>
 #include <vector>
@@ skipping 43 matching lines @@
   CHECK(PathService::Get(base::DIR_MODULE, &file_path));
   CHECK(media::InitializeMediaLibrary(file_path));
   return true;
 }
 
 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";
+const char kDecryptOnlyExternalClearKeyKeySystem[] =
+    "org.chromium.externalclearkey.decryptonly";
 const int64 kSecondsPerMinute = 60;
 const int64 kMsPerSecond = 1000;
 const int64 kInitialTimerDelayMs = 200;
 const int64 kMaxTimerDelayMs = 1 * kSecondsPerMinute * kMsPerSecond;
 // Heart beat message header. If a key message starts with |kHeartBeatHeader|,
 // it's a heart beat message. Otherwise, it's a key request.
 const char kHeartBeatHeader[] = "HEARTBEAT";
 
 // Copies |input_buffer| into a media::DecoderBuffer. If the |input_buffer| is
 // empty, an empty (end-of-stream) media::DecoderBuffer is returned.
@@ skipping 44 matching lines @@
 void INITIALIZE_CDM_MODULE() {
 #if defined(CLEAR_KEY_CDM_USE_FFMPEG_DECODER)
   DVLOG(2) << "FFmpeg libraries initialized: " << g_ffmpeg_lib_initialized;
   av_register_all();
 #endif  // CLEAR_KEY_CDM_USE_FFMPEG_DECODER
 }
 
 void DeinitializeCdmModule() {
 }
 
-void* CreateCdmInstance(
-    int cdm_interface_version,
-    const char* key_system, uint32_t key_system_size,
-    GetCdmHostFunc get_cdm_host_func, void* user_data) {
+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()";
 
-  if (std::string(key_system, key_system_size) != kExternalClearKeyKeySystem) {
+  std::string key_system_string(key_system, key_system_size);
+  if (key_system_string != kExternalClearKeyKeySystem &&
+      key_system_string != kDecryptOnlyExternalClearKeyKeySystem) {
     DVLOG(1) << "Unsupported key system.";

[ddorwin, 2013/11/21 04:10:58]

...system: " << key_system_string;

[xhwang, 2013/11/22 01:47:36]

Done.

     return NULL;
   }
 
   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;
 
-  return new media::ClearKeyCdm(host);
+  return new media::ClearKeyCdm(
+      host, key_system_string == kDecryptOnlyExternalClearKeyKeySystem);
 }
 
 const char* GetCdmVersion() {
   return kClearKeyCdmVersion;
 }
 
 namespace media {
 
 // Since all the calls to AesDecryptor are synchronous, pass a dummy value for
 // reference_id that is never exposed outside this class.
@@ skipping 33 matching lines @@
   key_message_ = message;
   default_url_ = default_url;
 }
 
 void ClearKeyCdm::Client::SetSessionId(uint32 reference_id,
                                        const std::string& session_id) {
   status_ = static_cast<Status>(status_ | kSetSessionId);
   session_id_ = session_id;
 }
 
-ClearKeyCdm::ClearKeyCdm(ClearKeyCdmHost* host)
+ClearKeyCdm::ClearKeyCdm(ClearKeyCdmHost* host, bool decrypt_only)
     : decryptor_(base::Bind(&Client::KeyAdded, base::Unretained(&client_)),
                  base::Bind(&Client::KeyError, base::Unretained(&client_)),
                  base::Bind(&Client::KeyMessage, base::Unretained(&client_)),
                  base::Bind(&Client::SetSessionId, base::Unretained(&client_))),
       host_(host),
+      decrypt_only_(decrypt_only),
       timer_delay_ms_(kInitialTimerDelayMs),
       timer_set_(false) {
 #if defined(CLEAR_KEY_CDM_USE_FAKE_AUDIO_DECODER)
   channel_count_ = 0;
   bits_per_channel_ = 0;
   samples_per_second_ = 0;
   output_timestamp_base_in_microseconds_ = kNoTimestamp;
   total_samples_generated_ = 0;
 #endif  // CLEAR_KEY_CDM_USE_FAKE_AUDIO_DECODER
 }
@@ skipping 128 matching lines @@
          buffer->data(),
          buffer->data_size());
   decrypted_block->DecryptedBuffer()->SetSize(buffer->data_size());
   decrypted_block->SetTimestamp(buffer->timestamp().InMicroseconds());
 
   return cdm::kSuccess;
 }
 
 cdm::Status ClearKeyCdm::InitializeAudioDecoder(
     const cdm::AudioDecoderConfig& audio_decoder_config) {
+  if (decrypt_only_)
+    return cdm::kSessionError;
+
 #if defined(CLEAR_KEY_CDM_USE_FFMPEG_DECODER)
   if (!audio_decoder_)
     audio_decoder_.reset(new media::FFmpegCdmAudioDecoder(host_));
 
   if (!audio_decoder_->Initialize(audio_decoder_config))
     return cdm::kSessionError;
 
   return cdm::kSuccess;
 #elif defined(CLEAR_KEY_CDM_USE_FAKE_AUDIO_DECODER)
   channel_count_ = audio_decoder_config.channel_count;
   bits_per_channel_ = audio_decoder_config.bits_per_channel;
   samples_per_second_ = audio_decoder_config.samples_per_second;
   return cdm::kSuccess;
 #else
   NOTIMPLEMENTED();
   return cdm::kSessionError;
 #endif  // CLEAR_KEY_CDM_USE_FFMPEG_DECODER
 }
 
 cdm::Status ClearKeyCdm::InitializeVideoDecoder(
     const cdm::VideoDecoderConfig& video_decoder_config) {
+  if (decrypt_only_)
+    return cdm::kSessionError;
+
   if (video_decoder_ && video_decoder_->is_initialized()) {
     DCHECK(!video_decoder_->is_initialized());
     return cdm::kSessionError;
   }
 
   // Any uninitialized decoder will be replaced.
   video_decoder_ = CreateVideoDecoder(host_, video_decoder_config);
   if (!video_decoder_)
     return cdm::kSessionError;
 
@@ skipping 212 matching lines @@
   int samples_generated = GenerateFakeAudioFramesFromDuration(
       timestamp_in_microseconds - CurrentTimeStampInMicroseconds(),
       audio_frames);
   total_samples_generated_ += samples_generated;
 
   return samples_generated == 0 ? cdm::kNeedMoreData : cdm::kSuccess;
 }
 #endif  // CLEAR_KEY_CDM_USE_FAKE_AUDIO_DECODER
 
 }  // namespace media