Switch to standard integer types in media/.

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"
@@ skipping 84 matching lines @@
       break;
   }
 
   NOTREACHED();
   return MediaKeys::TEMPORARY_SESSION;
 }
 
 static bool SanitizeInitData(EmeInitDataType init_data_type,
                              const unsigned char* init_data,
                              size_t init_data_length,
-                             std::vector<uint8>* sanitized_init_data,
+                             std::vector<uint8_t>* sanitized_init_data,
                              std::string* error_message) {
   if (init_data_length > limits::kMaxInitDataLength) {
     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;
@@ skipping 56 matching lines @@
 
   for (const char c : *sanitized_session_id) {
     if (!base::IsAsciiAlpha(c) && !base::IsAsciiDigit(c))
       return false;
   }
 
   return true;
 }
 
 static bool SanitizeResponse(const std::string& key_system,
-                             const uint8* response,
+                             const uint8_t* response,
                              size_t response_length,
-                             std::vector<uint8>* sanitized_response) {
+                             std::vector<uint8_t>* sanitized_response) {
   // The user agent should thoroughly validate the response before passing it
   // to the CDM. This may include verifying values are within reasonable limits,
   // stripping irrelevant data or fields, pre-parsing it, sanitizing it,
   // and/or generating a fully sanitized version. The user agent should check
   // that the length and values of fields are reasonable. Unknown fields should
   // be rejected or removed.
   if (response_length > limits::kMaxSessionResponseLength)
     return false;
 
   if (IsClearKey(key_system) || IsExternalClearKey(key_system)) {
@@ skipping 77 matching lines @@
   //     before passing it to the CDM. This includes verifying that the length
   //     and values of fields are reasonable, verifying that values are within
   //     reasonable limits, and stripping irrelevant, unsupported, or unknown
   //     data or fields. It is recommended that user agents pre-parse, sanitize,
   //     and/or generate a fully sanitized version of the Initialization Data.
   //     If the Initialization Data format specified by initDataType support
   //     multiple entries, the user agent should remove entries that are not
   //     needed by the CDM.
   // 9.3 If the previous step failed, reject promise with a new DOMException
   //     whose name is InvalidAccessError.
-  std::vector<uint8> sanitized_init_data;
+  std::vector<uint8_t> sanitized_init_data;
   std::string message;
   if (!SanitizeInitData(eme_init_data_type, init_data, init_data_length,
                         &sanitized_init_data, &message)) {
     result.completeWithError(
         blink::WebContentDecryptionModuleExceptionInvalidAccessError, 0,
         blink::WebString::fromUTF8(message));
     return;
   }
 
   // 9.4 Let session id be the empty string.
@@ skipping 35 matching lines @@
   adapter_->LoadSession(
       MediaKeys::PERSISTENT_LICENSE_SESSION, sanitized_session_id,
       scoped_ptr<NewSessionCdmPromise>(new NewSessionCdmResultPromise(
           result, adapter_->GetKeySystemUMAPrefix() + kLoadSessionUMAName,
           base::Bind(
               &WebContentDecryptionModuleSessionImpl::OnSessionInitialized,
               weak_ptr_factory_.GetWeakPtr()))));
 }
 
 void WebContentDecryptionModuleSessionImpl::update(
-    const uint8* response,
+    const uint8_t* response,
     size_t response_length,
     blink::WebContentDecryptionModuleResult result) {
   DCHECK(response);
   DCHECK(!session_id_.empty());
   DCHECK(thread_checker_.CalledOnValidThread());
 
-  std::vector<uint8> sanitized_response;
+  std::vector<uint8_t> sanitized_response;
   if (!SanitizeResponse(adapter_->GetKeySystem(), response, response_length,
                         &sanitized_response)) {
     result.completeWithError(
         blink::WebContentDecryptionModuleExceptionInvalidAccessError, 0,
         "Invalid response.");
     return;
   }
 
   adapter_->UpdateSession(
       session_id_, sanitized_response,
@@ skipping 16 matching lines @@
   DCHECK(!session_id_.empty());
   DCHECK(thread_checker_.CalledOnValidThread());
   adapter_->RemoveSession(
       session_id_,
       scoped_ptr<SimpleCdmPromise>(new CdmResultPromise<>(
           result, adapter_->GetKeySystemUMAPrefix() + kRemoveSessionUMAName)));
 }
 
 void WebContentDecryptionModuleSessionImpl::OnSessionMessage(
     MediaKeys::MessageType message_type,
-    const std::vector<uint8>& message) {
+    const std::vector<uint8_t>& message) {
   DCHECK(client_) << "Client not set before message event";
   DCHECK(thread_checker_.CalledOnValidThread());
   client_->message(convertMessageType(message_type), message.data(),
                    message.size());
 }
 
 void WebContentDecryptionModuleSessionImpl::OnSessionKeysChange(
     bool has_additional_usable_key,
     CdmKeysInfo keys_info) {
   DCHECK(thread_checker_.CalledOnValidThread());
@@ skipping 38 matching lines @@
 
   DCHECK(session_id_.empty()) << "Session ID may not be changed once set.";
   session_id_ = session_id;
   *status =
       adapter_->RegisterSession(session_id_, weak_ptr_factory_.GetWeakPtr())
           ? SessionInitStatus::NEW_SESSION
           : SessionInitStatus::SESSION_ALREADY_EXISTS;
 }
 
 }  // namespace media