Relocate last remnants of webkit/renderer/media code.

media/crypto/aes_decryptor.cc

Index: media/crypto/aes_decryptor.cc
diff --git a/media/crypto/aes_decryptor.cc b/media/crypto/aes_decryptor.cc
deleted file mode 100644
index fd7c628066c55b5eb58fdaaed53773e62485193a..0000000000000000000000000000000000000000
--- a/media/crypto/aes_decryptor.cc
+++ /dev/null
@@ -1,345 +0,0 @@
-// Copyright (c) 2012 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/crypto/aes_decryptor.h"
-
-#include <vector>
-
-#include "base/logging.h"
-#include "base/stl_util.h"
-#include "base/strings/string_number_conversions.h"
-#include "crypto/encryptor.h"
-#include "crypto/symmetric_key.h"
-#include "media/base/audio_decoder_config.h"
-#include "media/base/decoder_buffer.h"
-#include "media/base/decrypt_config.h"
-#include "media/base/video_decoder_config.h"
-#include "media/base/video_frame.h"
-
-namespace media {
-
-uint32 AesDecryptor::next_session_id_ = 1;
-
-enum ClearBytesBufferSel {
-  kSrcContainsClearBytes,
-  kDstContainsClearBytes
-};
-
-static void CopySubsamples(const std::vector<SubsampleEntry>& subsamples,
-                           const ClearBytesBufferSel sel,
-                           const uint8* src,
-                           uint8* dst) {
-  for (size_t i = 0; i < subsamples.size(); i++) {
-    const SubsampleEntry& subsample = subsamples[i];
-    if (sel == kSrcContainsClearBytes) {
-      src += subsample.clear_bytes;
-    } else {
-      dst += subsample.clear_bytes;
-    }
-    memcpy(dst, src, subsample.cypher_bytes);
-    src += subsample.cypher_bytes;
-    dst += subsample.cypher_bytes;
-  }
-}
-
-// Decrypts |input| using |key|.  Returns a DecoderBuffer with the decrypted
-// data if decryption succeeded or NULL if decryption failed.
-static scoped_refptr<DecoderBuffer> DecryptData(const DecoderBuffer& input,
-                                                crypto::SymmetricKey* key) {
-  CHECK(input.data_size());
-  CHECK(input.decrypt_config());
-  CHECK(key);
-
-  crypto::Encryptor encryptor;
-  if (!encryptor.Init(key, crypto::Encryptor::CTR, "")) {
-    DVLOG(1) << "Could not initialize decryptor.";
-    return NULL;
-  }
-
-  DCHECK_EQ(input.decrypt_config()->iv().size(),
-            static_cast<size_t>(DecryptConfig::kDecryptionKeySize));
-  if (!encryptor.SetCounter(input.decrypt_config()->iv())) {
-    DVLOG(1) << "Could not set counter block.";
-    return NULL;
-  }
-
-  const int data_offset = input.decrypt_config()->data_offset();
-  const char* sample =
-      reinterpret_cast<const char*>(input.data() + data_offset);
-  int sample_size = input.data_size() - data_offset;
-
-  DCHECK_GT(sample_size, 0) << "No sample data to be decrypted.";
-  if (sample_size <= 0)
-    return NULL;
-
-  if (input.decrypt_config()->subsamples().empty()) {
-    std::string decrypted_text;
-    base::StringPiece encrypted_text(sample, sample_size);
-    if (!encryptor.Decrypt(encrypted_text, &decrypted_text)) {
-      DVLOG(1) << "Could not decrypt data.";
-      return NULL;
-    }
-
-    // TODO(xhwang): Find a way to avoid this data copy.
-    return DecoderBuffer::CopyFrom(
-        reinterpret_cast<const uint8*>(decrypted_text.data()),
-        decrypted_text.size());
-  }
-
-  const std::vector<SubsampleEntry>& subsamples =
-      input.decrypt_config()->subsamples();
-
-  int total_clear_size = 0;
-  int total_encrypted_size = 0;
-  for (size_t i = 0; i < subsamples.size(); i++) {
-    total_clear_size += subsamples[i].clear_bytes;
-    total_encrypted_size += subsamples[i].cypher_bytes;
-  }
-  if (total_clear_size + total_encrypted_size != sample_size) {
-    DVLOG(1) << "Subsample sizes do not equal input size";
-    return NULL;
-  }
-
-  // No need to decrypt if there is no encrypted data.
-  if (total_encrypted_size <= 0) {
-    return DecoderBuffer::CopyFrom(reinterpret_cast<const uint8*>(sample),
-                                   sample_size);
-  }
-
-  // The encrypted portions of all subsamples must form a contiguous block,
-  // such that an encrypted subsample that ends away from a block boundary is
-  // immediately followed by the start of the next encrypted subsample. We
-  // copy all encrypted subsamples to a contiguous buffer, decrypt them, then
-  // copy the decrypted bytes over the encrypted bytes in the output.
-  // TODO(strobe): attempt to reduce number of memory copies
-  scoped_ptr<uint8[]> encrypted_bytes(new uint8[total_encrypted_size]);
-  CopySubsamples(subsamples, kSrcContainsClearBytes,
-                 reinterpret_cast<const uint8*>(sample), encrypted_bytes.get());
-
-  base::StringPiece encrypted_text(
-      reinterpret_cast<const char*>(encrypted_bytes.get()),
-      total_encrypted_size);
-  std::string decrypted_text;
-  if (!encryptor.Decrypt(encrypted_text, &decrypted_text)) {
-    DVLOG(1) << "Could not decrypt data.";
-    return NULL;
-  }
-  DCHECK_EQ(decrypted_text.size(), encrypted_text.size());
-
-  scoped_refptr<DecoderBuffer> output = DecoderBuffer::CopyFrom(
-      reinterpret_cast<const uint8*>(sample), sample_size);
-  CopySubsamples(subsamples, kDstContainsClearBytes,
-                 reinterpret_cast<const uint8*>(decrypted_text.data()),
-                 output->writable_data());
-  return output;
-}
-
-AesDecryptor::AesDecryptor(const KeyAddedCB& key_added_cb,
-                           const KeyErrorCB& key_error_cb,
-                           const KeyMessageCB& key_message_cb)
-    : key_added_cb_(key_added_cb),
-      key_error_cb_(key_error_cb),
-      key_message_cb_(key_message_cb) {
-}
-
-AesDecryptor::~AesDecryptor() {
-  STLDeleteValues(&key_map_);
-}
-
-bool AesDecryptor::GenerateKeyRequest(const std::string& type,
-                                      const uint8* init_data,
-                                      int init_data_length) {
-  std::string session_id_string(base::UintToString(next_session_id_++));
-
-  // For now, the AesDecryptor does not care about |type|;
-  // just fire the event with the |init_data| as the request.
-  std::vector<uint8> message;
-  if (init_data && init_data_length)
-    message.assign(init_data, init_data + init_data_length);
-
-  key_message_cb_.Run(session_id_string, message, std::string());
-  return true;
-}
-
-void AesDecryptor::AddKey(const uint8* key,
-                          int key_length,
-                          const uint8* init_data,
-                          int init_data_length,
-                          const std::string& session_id) {
-  CHECK(key);
-  CHECK_GT(key_length, 0);
-
-  // TODO(xhwang): Add |session_id| check after we figure out how:
-  // https://www.w3.org/Bugs/Public/show_bug.cgi?id=16550
-  if (key_length != DecryptConfig::kDecryptionKeySize) {
-    DVLOG(1) << "Invalid key length: " << key_length;
-    key_error_cb_.Run(session_id, MediaKeys::kUnknownError, 0);
-    return;
-  }
-
-  // TODO(xhwang): Fix the decryptor to accept no |init_data|. See
-  // http://crbug.com/123265. Until then, ensure a non-empty value is passed.
-  static const uint8 kDummyInitData[1] = { 0 };
-  if (!init_data) {
-    init_data = kDummyInitData;
-    init_data_length = arraysize(kDummyInitData);
-  }
-
-  // TODO(xhwang): For now, use |init_data| for key ID. Make this more spec
-  // compliant later (http://crbug.com/123262, http://crbug.com/123265).
-  std::string key_id_string(reinterpret_cast<const char*>(init_data),
-                            init_data_length);
-  std::string key_string(reinterpret_cast<const char*>(key) , key_length);
-  scoped_ptr<DecryptionKey> decryption_key(new DecryptionKey(key_string));
-  if (!decryption_key) {
-    DVLOG(1) << "Could not create key.";
-    key_error_cb_.Run(session_id, MediaKeys::kUnknownError, 0);
-    return;
-  }
-
-  if (!decryption_key->Init()) {
-    DVLOG(1) << "Could not initialize decryption key.";
-    key_error_cb_.Run(session_id, MediaKeys::kUnknownError, 0);
-    return;
-  }
-
-  SetKey(key_id_string, decryption_key.Pass());
-
-  if (!new_audio_key_cb_.is_null())
-    new_audio_key_cb_.Run();
-
-  if (!new_video_key_cb_.is_null())
-    new_video_key_cb_.Run();
-
-  key_added_cb_.Run(session_id);
-}
-
-void AesDecryptor::CancelKeyRequest(const std::string& session_id) {
-}
-
-Decryptor* AesDecryptor::GetDecryptor() {
-  return this;
-}
-
-void AesDecryptor::RegisterNewKeyCB(StreamType stream_type,
-                                    const NewKeyCB& new_key_cb) {
-  switch (stream_type) {
-    case kAudio:
-      new_audio_key_cb_ = new_key_cb;
-      break;
-    case kVideo:
-      new_video_key_cb_ = new_key_cb;
-      break;
-    default:
-      NOTREACHED();
-  }
-}
-
-void AesDecryptor::Decrypt(StreamType stream_type,
-                           const scoped_refptr<DecoderBuffer>& encrypted,
-                           const DecryptCB& decrypt_cb) {
-  CHECK(encrypted->decrypt_config());
-
-  scoped_refptr<DecoderBuffer> decrypted;
-  // An empty iv string signals that the frame is unencrypted.
-  if (encrypted->decrypt_config()->iv().empty()) {
-    int data_offset = encrypted->decrypt_config()->data_offset();
-    decrypted = DecoderBuffer::CopyFrom(encrypted->data() + data_offset,
-                                        encrypted->data_size() - data_offset);
-  } else {
-    const std::string& key_id = encrypted->decrypt_config()->key_id();
-    DecryptionKey* key = GetKey(key_id);
-    if (!key) {
-      DVLOG(1) << "Could not find a matching key for the given key ID.";
-      decrypt_cb.Run(kNoKey, NULL);
-      return;
-    }
-
-    crypto::SymmetricKey* decryption_key = key->decryption_key();
-    decrypted = DecryptData(*encrypted.get(), decryption_key);
-    if (!decrypted.get()) {
-      DVLOG(1) << "Decryption failed.";
-      decrypt_cb.Run(kError, NULL);
-      return;
-    }
-  }
-
-  decrypted->set_timestamp(encrypted->timestamp());
-  decrypted->set_duration(encrypted->duration());
-  decrypt_cb.Run(kSuccess, decrypted);
-}
-
-void AesDecryptor::CancelDecrypt(StreamType stream_type) {
-  // Decrypt() calls the DecryptCB synchronously so there's nothing to cancel.
-}
-
-void AesDecryptor::InitializeAudioDecoder(const AudioDecoderConfig& config,
-                                          const DecoderInitCB& init_cb) {
-  // AesDecryptor does not support audio decoding.
-  init_cb.Run(false);
-}
-
-void AesDecryptor::InitializeVideoDecoder(const VideoDecoderConfig& config,
-                                          const DecoderInitCB& init_cb) {
-  // AesDecryptor does not support video decoding.
-  init_cb.Run(false);
-}
-
-void AesDecryptor::DecryptAndDecodeAudio(
-    const scoped_refptr<DecoderBuffer>& encrypted,
-    const AudioDecodeCB& audio_decode_cb) {
-  NOTREACHED() << "AesDecryptor does not support audio decoding";
-}
-
-void AesDecryptor::DecryptAndDecodeVideo(
-    const scoped_refptr<DecoderBuffer>& encrypted,
-    const VideoDecodeCB& video_decode_cb) {
-  NOTREACHED() << "AesDecryptor does not support video decoding";
-}
-
-void AesDecryptor::ResetDecoder(StreamType stream_type) {
-  NOTREACHED() << "AesDecryptor does not support audio/video decoding";
-}
-
-void AesDecryptor::DeinitializeDecoder(StreamType stream_type) {
-  NOTREACHED() << "AesDecryptor does not support audio/video decoding";
-}
-
-void AesDecryptor::SetKey(const std::string& key_id,
-                          scoped_ptr<DecryptionKey> decryption_key) {
-  base::AutoLock auto_lock(key_map_lock_);
-  KeyMap::iterator found = key_map_.find(key_id);
-  if (found != key_map_.end()) {
-    delete found->second;
-    key_map_.erase(found);
-  }
-  key_map_[key_id] = decryption_key.release();
-}
-
-AesDecryptor::DecryptionKey* AesDecryptor::GetKey(
-    const std::string& key_id) const {
-  base::AutoLock auto_lock(key_map_lock_);
-  KeyMap::const_iterator found = key_map_.find(key_id);
-  if (found == key_map_.end())
-    return NULL;
-
-  return found->second;
-}
-
-AesDecryptor::DecryptionKey::DecryptionKey(const std::string& secret)
-    : secret_(secret) {
-}
-
-AesDecryptor::DecryptionKey::~DecryptionKey() {}
-
-bool AesDecryptor::DecryptionKey::Init() {
-  CHECK(!secret_.empty());
-  decryption_key_.reset(crypto::SymmetricKey::Import(
-      crypto::SymmetricKey::AES, secret_));
-  if (!decryption_key_)
-    return false;
-  return true;
-}
-
-}  // namespace media