Inject CanAddURLToHistory into TopSitesImpl

media/blink/webcontentdecryptionmodulesession_impl.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 "webcontentdecryptionmodulesession_impl.h"
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/logging.h"
 #include "base/numerics/safe_conversions.h"
+#include "base/stl_util.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "media/base/cdm_key_information.h"
 #include "media/base/cdm_promise.h"
 #include "media/base/key_systems.h"
 #include "media/base/limits.h"
 #include "media/base/media_keys.h"
 #include "media/blink/cdm_result_promise.h"
 #include "media/blink/cdm_session_adapter.h"
 #include "media/blink/new_session_cdm_result_promise.h"
@@ skipping 82 matching lines @@
     error_message->assign("Initialization data too long.");
     return false;
   }
 
   switch (init_data_type) {
     case EmeInitDataType::WEBM:
       sanitized_init_data->assign(init_data, init_data + init_data_length);
       return true;
 
     case EmeInitDataType::CENC:
-      if (!ValidatePsshInput(init_data, init_data_length)) {
+      sanitized_init_data->assign(init_data, init_data + init_data_length);
+      if (!ValidatePsshInput(*sanitized_init_data)) {
         error_message->assign("Initialization data for CENC is incorrect.");
         return false;
       }
-
-      sanitized_init_data->assign(init_data, init_data + init_data_length);
       return true;
 
     case EmeInitDataType::KEYIDS: {
       // Extract the keys and then rebuild the message. This ensures that any
       // extra data in the provided JSON is dropped.
       std::string init_data_string(init_data, init_data + init_data_length);
       KeyIdList key_ids;
       if (!ExtractKeyIdsFromKeyIdsInitData(init_data_string, &key_ids,
                                            error_message))
         return false;
@@ skipping 37 matching lines @@
 blink::WebString WebContentDecryptionModuleSessionImpl::sessionId() const {
   return blink::WebString::fromUTF8(session_id_);
 }
 
 void WebContentDecryptionModuleSessionImpl::initializeNewSession(
     blink::WebEncryptedMediaInitDataType init_data_type,
     const unsigned char* init_data,
     size_t init_data_length,
     blink::WebEncryptedMediaSessionType session_type,
     blink::WebContentDecryptionModuleResult result) {
+  DCHECK(init_data);
   DCHECK(session_id_.empty());
 
   // From https://w3c.github.io/encrypted-media/#generateRequest.
   // 5. If the Key System implementation represented by this object's cdm
   //    implementation value does not support initDataType as an Initialization
   //    Data Type, return a promise rejected with a new DOMException whose name
   //    is NotSupportedError. String comparison is case-sensitive.
   EmeInitDataType eme_init_data_type = ConvertToEmeInitDataType(init_data_type);
   if (!IsSupportedKeySystemWithInitDataType(adapter_->GetKeySystem(),
                                             eme_init_data_type)) {
@@ skipping 32 matching lines @@
   // 9.4 Let session id be the empty string.
   //     (Done in constructor.)
 
   // 9.5 Let message be null.
   //     (Done by CDM.)
 
   // 9.6 Let cdm be the CDM instance represented by this object's cdm
   //     instance value.
   // 9.7 Use the cdm to execute the following steps:
   adapter_->InitializeNewSession(
-      eme_init_data_type, vector_as_array(&sanitized_init_data),
-      base::saturated_cast<int>(sanitized_init_data.size()),
-      convertSessionType(session_type),
+      eme_init_data_type, sanitized_init_data, convertSessionType(session_type),
       scoped_ptr<NewSessionCdmPromise>(new NewSessionCdmResultPromise(
           result, adapter_->GetKeySystemUMAPrefix() + kGenerateRequestUMAName,
           base::Bind(
               &WebContentDecryptionModuleSessionImpl::OnSessionInitialized,
               base::Unretained(this)))));
 }
 
 void WebContentDecryptionModuleSessionImpl::load(
     const blink::WebString& session_id,
     blink::WebContentDecryptionModuleResult result) {
@@ skipping 12 matching lines @@
               base::Unretained(this)))));
 }
 
 void WebContentDecryptionModuleSessionImpl::update(
     const uint8* response,
     size_t response_length,
     blink::WebContentDecryptionModuleResult result) {
   DCHECK(response);
   DCHECK(!session_id_.empty());
   adapter_->UpdateSession(
-      session_id_, response, base::saturated_cast<int>(response_length),
+      session_id_, std::vector<uint8>(response, response + response_length),
       scoped_ptr<SimpleCdmPromise>(new CdmResultPromise<>(
           result, adapter_->GetKeySystemUMAPrefix() + kUpdateSessionUMAName)));
 }
 
 void WebContentDecryptionModuleSessionImpl::close(
     blink::WebContentDecryptionModuleResult result) {
   DCHECK(!session_id_.empty());
   adapter_->CloseSession(
       session_id_,
       scoped_ptr<SimpleCdmPromise>(new CdmResultPromise<>(
@@ skipping 55 matching lines @@
     return blink::WebContentDecryptionModuleResult::SessionNotFound;
 
   DCHECK(session_id_.empty()) << "Session ID may not be changed once set.";
   session_id_ = session_id;
   return adapter_->RegisterSession(session_id_, weak_ptr_factory_.GetWeakPtr())
              ? blink::WebContentDecryptionModuleResult::NewSession
              : blink::WebContentDecryptionModuleResult::SessionAlreadyExists;
 }
 
 }  // namespace media