Inject CanAddURLToHistory into TopSitesImpl

media/cdm/aes_decryptor.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/aes_decryptor.h"
 
 #include <list>
 #include <vector>
 
 #include "base/logging.h"
@@ skipping 87 matching lines @@
   return key_list_.end();
 }
 
 void AesDecryptor::SessionIdDecryptionKeyMap::Erase(
     KeyList::iterator position) {
   DCHECK(position->second);
   delete position->second;
   key_list_.erase(position);
 }
 
-uint32 AesDecryptor::next_session_id_ = 1;
+uint32_t 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) {
+                           const uint8_t* src,
+                           uint8_t* 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;
@@ skipping 31 matching lines @@
   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()),
+        reinterpret_cast<const uint8_t*>(decrypted_text.data()),
         decrypted_text.size());
   }
 
   const std::vector<SubsampleEntry>& subsamples =
       input.decrypt_config()->subsamples();
 
   size_t total_clear_size = 0;
   size_t 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;
     // Check for overflow. This check is valid because *_size is unsigned.
     DCHECK(total_clear_size >= subsamples[i].clear_bytes);
     if (total_encrypted_size < subsamples[i].cypher_bytes)
       return NULL;
   }
   size_t total_size = total_clear_size + total_encrypted_size;
   if (total_size < total_clear_size || total_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),
+    return DecoderBuffer::CopyFrom(reinterpret_cast<const uint8_t*>(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]);
+  scoped_ptr<uint8_t[]> encrypted_bytes(new uint8_t[total_encrypted_size]);
   CopySubsamples(subsamples, kSrcContainsClearBytes,
-                 reinterpret_cast<const uint8*>(sample), encrypted_bytes.get());
+                 reinterpret_cast<const uint8_t*>(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);
+      reinterpret_cast<const uint8_t*>(sample), sample_size);
   CopySubsamples(subsamples, kDstContainsClearBytes,
-                 reinterpret_cast<const uint8*>(decrypted_text.data()),
+                 reinterpret_cast<const uint8_t*>(decrypted_text.data()),
                  output->writable_data());
   return output;
 }
 
 AesDecryptor::AesDecryptor(const GURL& /* security_origin */,
                            const SessionMessageCB& session_message_cb,
                            const SessionClosedCB& session_closed_cb,
                            const SessionKeysChangeCB& session_keys_change_cb)
     : session_message_cb_(session_message_cb),
       session_closed_cb_(session_closed_cb),
       session_keys_change_cb_(session_keys_change_cb) {
   // AesDecryptor doesn't keep any persistent data, so no need to do anything
   // with |security_origin|.
   DCHECK(!session_message_cb_.is_null());
   DCHECK(!session_closed_cb_.is_null());
   DCHECK(!session_keys_change_cb_.is_null());
 }
 
 AesDecryptor::~AesDecryptor() {
   key_map_.clear();
 }
 
-void AesDecryptor::SetServerCertificate(const uint8* certificate_data,
-                                        int certificate_data_length,
+void AesDecryptor::SetServerCertificate(const std::vector<uint8_t>& certificate,
                                         scoped_ptr<SimpleCdmPromise> promise) {
   promise->reject(
       NOT_SUPPORTED_ERROR, 0, "SetServerCertificate() is not supported.");
 }
 
 void AesDecryptor::CreateSessionAndGenerateRequest(
     SessionType session_type,
     EmeInitDataType init_data_type,
-    const uint8* init_data,
-    int init_data_length,
+    const std::vector<uint8_t>& init_data,
     scoped_ptr<NewSessionCdmPromise> promise) {
   std::string session_id(base::UintToString(next_session_id_++));
   valid_sessions_.insert(session_id);
 
   // For now, the AesDecryptor does not care about |session_type|.
   // TODO(jrummell): Validate |session_type|.
 
-  std::vector<uint8> message;
+  std::vector<uint8_t> message;
   // TODO(jrummell): Since unprefixed will never send NULL, remove this check
   // when prefixed EME is removed (http://crbug.com/249976).
-  if (init_data && init_data_length) {
-    std::vector<std::vector<uint8>> keys;
+  if (!init_data.empty()) {
+    std::vector<std::vector<uint8_t>> keys;
     switch (init_data_type) {
       case EmeInitDataType::WEBM:
         // |init_data| is simply the key needed.
-        keys.push_back(
-            std::vector<uint8>(init_data, init_data + init_data_length));
+        keys.push_back(init_data);
         break;
       case EmeInitDataType::CENC:
         // |init_data| is a set of 0 or more concatenated 'pssh' boxes.
-        if (!GetKeyIdsForCommonSystemId(init_data, init_data_length, &keys)) {
+        if (!GetKeyIdsForCommonSystemId(init_data, &keys)) {
           promise->reject(NOT_SUPPORTED_ERROR, 0,
                           "No supported PSSH box found.");
           return;
         }
         break;
       case EmeInitDataType::KEYIDS: {
-        std::string init_data_string(init_data, init_data + init_data_length);
+        std::string init_data_string(init_data.begin(), init_data.end());
         std::string error_message;
         if (!ExtractKeyIdsFromKeyIdsInitData(init_data_string, &keys,
                                              &error_message)) {
           promise->reject(NOT_SUPPORTED_ERROR, 0, error_message);
           return;
         }
         break;
       }
       default:
         NOTREACHED();
@@ skipping 13 matching lines @@
 
 void AesDecryptor::LoadSession(SessionType session_type,
                                const std::string& session_id,
                                scoped_ptr<NewSessionCdmPromise> promise) {
   // TODO(xhwang): Change this to NOTREACHED() when blink checks for key systems
   // that do not support loadSession. See http://crbug.com/342481
   promise->reject(NOT_SUPPORTED_ERROR, 0, "LoadSession() is not supported.");
 }
 
 void AesDecryptor::UpdateSession(const std::string& session_id,
-                                 const uint8* response,
-                                 int response_length,
+                                 const std::vector<uint8_t>& response,
                                  scoped_ptr<SimpleCdmPromise> promise) {
-  CHECK(response);
-  CHECK_GT(response_length, 0);
+  CHECK(!response.empty());
 
   // TODO(jrummell): Convert back to a DCHECK once prefixed EME is removed.
   if (valid_sessions_.find(session_id) == valid_sessions_.end()) {
     promise->reject(INVALID_ACCESS_ERROR, 0, "Session does not exist.");
     return;
   }
 
-  std::string key_string(reinterpret_cast<const char*>(response),
-                         response_length);
+  std::string key_string(response.begin(), response.end());
 
   KeyIdAndKeyPairs keys;
   SessionType session_type = MediaKeys::TEMPORARY_SESSION;
   if (!ExtractKeysFromJWKSet(key_string, &keys, &session_type)) {
     promise->reject(
         INVALID_ACCESS_ERROR, 0, "Response is not a valid JSON Web Key Set.");
     return;
   }
 
   // Make sure that at least one key was extracted.
@@ skipping 258 matching lines @@
 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