Add CDM FileIO 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>
 
 #include "base/bind.h"
 #include "base/debug/trace_event.h"
 #include "base/logging.h"
 #include "base/time/time.h"
 #include "media/base/decoder_buffer.h"
 #include "media/base/decrypt_config.h"
+#include "media/cdm/ppapi/cdm_file_io_test.h"
 #include "media/cdm/ppapi/cdm_video_decoder.h"
 
 #if defined(CLEAR_KEY_CDM_USE_FAKE_AUDIO_DECODER)
 #include "base/basictypes.h"
 const int64 kNoTimestamp = kint64min;
 #endif  // CLEAR_KEY_CDM_USE_FAKE_AUDIO_DECODER
 
 #if defined(CLEAR_KEY_CDM_USE_FFMPEG_DECODER)
 #include "base/at_exit.h"
 #include "base/files/file_path.h"
@@ skipping 28 matching lines @@
   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 kExternalClearKeyDecryptOnlyKeySystem[] =
     "org.chromium.externalclearkey.decryptonly";
+const char kExternalClearKeyFileIOTestKeySystem[] =
+    "org.chromium.externalclearkey.fileiotest";
 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";
+// CDM file IO test result header.
+const char kFileIOTestResultHeader[] = "FILEIOTESTRESULT";
 
 // 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 17 matching lines @@
       input_buffer.data_offset,
       subsamples));
 
   output_buffer->set_decrypt_config(decrypt_config.Pass());
   output_buffer->set_timestamp(
       base::TimeDelta::FromMicroseconds(input_buffer.timestamp));
 
   return output_buffer;
 }
 
+static std::string GetFileIOTestResultMessage(bool success) {
+  std::string message(kFileIOTestResultHeader);
+  message += success ? '1' : '0';
+  return message;
+}
+
 template<typename Type>
 class ScopedResetter {
  public:
   explicit ScopedResetter(Type* object) : object_(object) {}
   ~ScopedResetter() { object_->Reset(); }
 
  private:
   Type* const object_;
 };
 
 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) {
   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 != kExternalClearKeyDecryptOnlyKeySystem &&
+      key_system_string != kExternalClearKeyFileIOTestKeySystem) {
     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));
   if (!host)
     return NULL;
 
   return new media::ClearKeyCdm(
-      host, key_system_string == kExternalClearKeyDecryptOnlyKeySystem);
+      host,
+      key_system_string == kExternalClearKeyDecryptOnlyKeySystem,
+      key_system_string == kExternalClearKeyFileIOTestKeySystem);
 }
 
 const char* GetCdmVersion() {
   return kClearKeyCdmVersion;
 }
 
 namespace media {
 
 // Since all the calls to AesDecryptor are synchronous, pass a dummy value for
 // session_id that is never exposed outside this class.
@@ skipping 37 matching lines @@
 }
 
 void ClearKeyCdm::Client::OnSessionError(uint32 session_id,
                                          media::MediaKeys::KeyError error_code,
                                          int system_code) {
   status_ = static_cast<Status>(status_ | kError);
   error_code_ = error_code;
   system_code_ = system_code;
 }
 
-ClearKeyCdm::ClearKeyCdm(ClearKeyCdmHost* host, bool is_decrypt_only)
+ClearKeyCdm::ClearKeyCdm(ClearKeyCdmHost* host,
+                         bool is_decrypt_only,
+                         bool should_test_file_io)
     : decryptor_(
           base::Bind(&Client::OnSessionCreated, base::Unretained(&client_)),
           base::Bind(&Client::OnSessionMessage, base::Unretained(&client_)),
           base::Bind(&Client::OnSessionReady, base::Unretained(&client_)),
           base::Bind(&Client::OnSessionClosed, base::Unretained(&client_)),
           base::Bind(&Client::OnSessionError, base::Unretained(&client_))),
       host_(host),
       is_decrypt_only_(is_decrypt_only),
+      should_test_file_io_(should_test_file_io),
       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 13 matching lines @@
 
   if (client_.status() != (Client::kMessage | Client::kCreated)) {
     // Use values returned to client if possible.
     host_->SendKeyError(client_.web_session_id().data(),
                         client_.web_session_id().size(),
                         static_cast<cdm::MediaKeyError>(client_.error_code()),
                         client_.system_code());
     return cdm::kSessionError;
   }
 
+  std::string web_session_id = client_.web_session_id();
+
   host_->SendKeyMessage(
-      client_.web_session_id().data(), client_.web_session_id().size(),
+      web_session_id.data(), web_session_id.size(),
       reinterpret_cast<const char*>(&client_.message()[0]),
       client_.message().size(),
       client_.destination_url().data(), client_.destination_url().size());
 
-  // Only save the latest session ID for heartbeat messages.
-  heartbeat_session_id_ = client_.web_session_id();
+  // Save the latest session ID for heartbeat and file IO test messages.
+  last_session_id_ = web_session_id;
+
+  if (should_test_file_io_)
+    StartFileIOTest();
 
   return cdm::kSuccess;
 }
 
 cdm::Status ClearKeyCdm::AddKey(const char* session_id,
                                 uint32_t session_id_size,
                                 const uint8_t* key,
                                 uint32_t key_size,
                                 const uint8_t* key_id,
                                 uint32_t key_id_size) {
@@ skipping 44 matching lines @@
     heartbeat_message = next_heartbeat_message_;
   } else {
     heartbeat_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_->SendKeyMessage(
-      heartbeat_session_id_.data(), heartbeat_session_id_.size(),
+      last_session_id_.data(), last_session_id_.size(),
       heartbeat_message.data(), heartbeat_message.size(),
       url, arraysize(url) - 1);
 
   ScheduleNextHeartBeat();
 }
 
 static void CopyDecryptResults(
     media::Decryptor::Status* status_copy,
     scoped_refptr<media::DecoderBuffer>* buffer_copy,
     media::Decryptor::Status status,
@@ skipping 279 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::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_->SendKeyMessage(last_session_id_.data(), last_session_id_.size(),
+                        message.data(), message.size(),
+                        NULL, 0);
+  file_io_test_runner_.reset();
+}
+
 }  // namespace media