media: Add OutputProtectionProxy

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 40 matching lines @@
 static bool InitializeFFmpegLibraries() {
   media::InitializeMediaLibrary();
   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";
+
+// Variants of External Clear Key key system to test different scenarios.
 const char kExternalClearKeyDecryptOnlyKeySystem[] =
     "org.chromium.externalclearkey.decryptonly";
 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 file IO test result header.
-const char kFileIOTestResultHeader[] = "FILEIOTESTRESULT";
+
+// 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) {
     DCHECK(!input_buffer.data_size);
     return media::DecoderBuffer::CreateEOSBuffer();
   }
 
@@ skipping 15 matching lines @@
                   input_buffer.iv_size),
       subsamples));
 
   output_buffer->set_decrypt_config(std::move(decrypt_config));
   output_buffer->set_timestamp(
       base::TimeDelta::FromMicroseconds(input_buffer.timestamp));
 
   return output_buffer;
 }
 
-static std::string GetFileIOTestResultMessage(bool success) {
-  std::string message(kFileIOTestResultHeader);
+static std::string GetUnitTestResultMessage(bool success) {
+  std::string message(kUnitTestResultHeader);
   message += success ? '1' : '0';
   return message;
 }
 
 static cdm::Error ConvertException(media::MediaKeys::Exception exception_code) {
   switch (exception_code) {
     case media::MediaKeys::NOT_SUPPORTED_ERROR:
       return cdm::kNotSupportedError;
     case media::MediaKeys::INVALID_STATE_ERROR:
       return cdm::kInvalidStateError;
@@ skipping 91 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 != 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;
 
   media::ClearKeyCdmHost* host = static_cast<media::ClearKeyCdmHost*>(
       get_cdm_host_func(media::ClearKeyCdmHost::kVersion, user_data));
@@ skipping 17 matching lines @@
     : decryptor_(new AesDecryptor(
           origin,
           base::Bind(&ClearKeyCdm::OnSessionMessage, base::Unretained(this)),
           base::Bind(&ClearKeyCdm::OnSessionClosed, base::Unretained(this)),
           base::Bind(&ClearKeyCdm::OnSessionKeysChange,
                      base::Unretained(this)))),
       host_(host),
       key_system_(key_system),
       has_received_keys_change_event_for_emulated_loadsession_(false),
       timer_delay_ms_(kInitialTimerDelayMs),
-      renewal_timer_set_(false) {
+      renewal_timer_set_(false),
+      is_running_output_protection_test_(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
 }
 
 ClearKeyCdm::~ClearKeyCdm() {}
@@ skipping 16 matching lines @@
       new media::CdmCallbackPromise<std::string>(
           base::Bind(&ClearKeyCdm::OnSessionCreated, base::Unretained(this),
                      promise_id),
           base::Bind(&ClearKeyCdm::OnPromiseFailed, base::Unretained(this),
                      promise_id)));
   decryptor_->CreateSessionAndGenerateRequest(
       ConvertSessionType(session_type), ConvertInitDataType(init_data_type),
       std::vector<uint8_t>(init_data, init_data + init_data_size),
       std::move(promise));
 
-  if (key_system_ == kExternalClearKeyFileIOTestKeySystem)
+  if (key_system_ == kExternalClearKeyFileIOTestKeySystem) {
     StartFileIOTest();
+  } else if (key_system_ == kExternalClearKeyOutputProtectionTestKeySystem) {
+    StartOutputProtectionTest();
+  }
 }
 
 // Loads a emulated stored session. Currently only |kLoadableSessionId|
 // (containing a |kLoadableSessionKey| for |kLoadableSessionKeyId|) is
 // supported.
 void ClearKeyCdm::LoadSession(uint32_t promise_id,
                               cdm::SessionType session_type,
                               const char* session_id,
                               uint32_t session_id_length) {
   DVLOG(1) << __FUNCTION__;
@@ skipping 366 matching lines @@
 
 void ClearKeyCdm::OnPlatformChallengeResponse(
     const cdm::PlatformChallengeResponse& response) {
   NOTIMPLEMENTED();
 }
 
 void ClearKeyCdm::OnQueryOutputProtectionStatus(
     cdm::QueryResult result,
     uint32_t link_mask,
     uint32_t output_protection_mask) {
-  NOTIMPLEMENTED();
+  if (!is_running_output_protection_test_) {
+    NOTREACHED() << "OnQueryOutputProtectionStatus() called unexpectedly.";
+    return;
+  }
+
+  is_running_output_protection_test_ = false;
+
+// On Chrome OS, status query will fail on Linux Chrome OS build. So we ignore
+// the query result. On all other platforms, status query should succeed.
+// TODO(xhwang): Improve the check on Chrome OS builds. For example, use
+// base::SysInfo::IsRunningOnChromeOS() to differentiate between real Chrome OS
+// build and Linux Chrome OS build.
+#if !defined(OS_CHROMEOS)
+  if (result != cdm::kQuerySucceeded || link_mask != 0) {
+    OnUnitTestComplete(false);
+    return;
+  }
+#endif
+  OnUnitTestComplete(true);
 };
 
 void ClearKeyCdm::LoadLoadableSession() {
   std::string jwk_set = GenerateJWKSet(kLoadableSessionKey,
                                        sizeof(kLoadableSessionKey),
                                        kLoadableSessionKeyId,
                                        sizeof(kLoadableSessionKeyId) - 1);
   std::unique_ptr<media::SimpleCdmPromise> promise(
       new media::CdmCallbackPromise<>(
           base::Bind(&ClearKeyCdm::OnLoadSessionUpdated,
@@ skipping 188 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
 
+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);
+}
+
 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;
-  std::string message = GetFileIOTestResultMessage(success);
-  host_->OnSessionMessage(last_session_id_.data(), last_session_id_.length(),
-                          cdm::kLicenseRequest, message.data(),
-                          message.length(), NULL, 0);
+  OnUnitTestComplete(success);
   file_io_test_runner_.reset();
 }
 
+void ClearKeyCdm::StartOutputProtectionTest() {
+  is_running_output_protection_test_ = true;
+  host_->QueryOutputProtectionStatus();
+}
+
 }  // namespace media