Switch to standard integer types in media/.

media/cdm/proxy_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/proxy_decryptor.h"
 
 #include <cstring>
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
@@ skipping 10 matching lines @@
 
 namespace media {
 
 // Special system code to signal a closed persistent session in a SessionError()
 // call. This is needed because there is no SessionClosed() call in the prefixed
 // EME API.
 const int kSessionClosedSystemCode = 29127;
 
 ProxyDecryptor::PendingGenerateKeyRequestData::PendingGenerateKeyRequestData(
     EmeInitDataType init_data_type,
-    const std::vector<uint8>& init_data)
-    : init_data_type(init_data_type), init_data(init_data) {
-}
+    const std::vector<uint8_t>& init_data)
+    : init_data_type(init_data_type), init_data(init_data) {}
 
 ProxyDecryptor::PendingGenerateKeyRequestData::
     ~PendingGenerateKeyRequestData() {
 }
 
 ProxyDecryptor::ProxyDecryptor(MediaPermission* media_permission,
                                bool use_hw_secure_codecs,
                                const KeyAddedCB& key_added_cb,
                                const KeyErrorCB& key_error_cb,
                                const KeyMessageCB& key_message_cb)
@@ skipping 66 matching lines @@
     cdm_context_ready_cb.Run(media_keys_->GetCdmContext());
   }
 
   for (const auto& request : pending_requests_)
     GenerateKeyRequestInternal(request->init_data_type, request->init_data);
 
   pending_requests_.clear();
 }
 
 void ProxyDecryptor::GenerateKeyRequest(EmeInitDataType init_data_type,
-                                        const uint8* init_data,
+                                        const uint8_t* init_data,
                                         int init_data_length) {
-  std::vector<uint8> init_data_vector(init_data, init_data + init_data_length);
+  std::vector<uint8_t> init_data_vector(init_data,
+                                        init_data + init_data_length);
 
   if (is_creating_cdm_) {
     pending_requests_.push_back(
         new PendingGenerateKeyRequestData(init_data_type, init_data_vector));
     return;
   }
 
   GenerateKeyRequestInternal(init_data_type, init_data_vector);
 }
 
 // Returns true if |data| is prefixed with |header| and has data after the
 // |header|.
-static bool HasHeader(const std::vector<uint8>& data,
+static bool HasHeader(const std::vector<uint8_t>& data,
                       const std::string& header) {
   return data.size() > header.size() &&
          std::equal(header.begin(), header.end(), data.begin());
 }
 
 // Removes the first |length| items from |data|.
-static void StripHeader(std::vector<uint8>& data, size_t length) {
+static void StripHeader(std::vector<uint8_t>& data, size_t length) {
   data.erase(data.begin(), data.begin() + length);
 }
 
 void ProxyDecryptor::GenerateKeyRequestInternal(
     EmeInitDataType init_data_type,
-    const std::vector<uint8>& init_data) {
+    const std::vector<uint8_t>& init_data) {
   DVLOG(1) << __FUNCTION__;
   DCHECK(!is_creating_cdm_);
 
   if (!media_keys_) {
     OnLegacySessionError(std::string(), MediaKeys::NOT_SUPPORTED_ERROR, 0,
                          "CDM creation failed.");
     return;
   }
 
   const char kPrefixedApiPersistentSessionHeader[] = "PERSISTENT|";
   const char kPrefixedApiLoadSessionHeader[] = "LOAD_SESSION|";
 
   SessionCreationType session_creation_type = TemporarySession;
-  std::vector<uint8> stripped_init_data = init_data;
+  std::vector<uint8_t> stripped_init_data = init_data;
   if (HasHeader(init_data, kPrefixedApiLoadSessionHeader)) {
     session_creation_type = LoadSession;
     StripHeader(stripped_init_data, strlen(kPrefixedApiLoadSessionHeader));
   } else if (HasHeader(init_data, kPrefixedApiPersistentSessionHeader)) {
     session_creation_type = PersistentSession;
     StripHeader(stripped_init_data,
                 strlen(kPrefixedApiPersistentSessionHeader));
   }
 
   scoped_ptr<NewSessionCdmPromise> promise(new CdmCallbackPromise<std::string>(
@@ skipping 34 matching lines @@
                  stripped_init_data, base::Passed(&promise)));
 #else
   OnPermissionStatus(session_type, init_data_type, stripped_init_data,
                      promise.Pass(), true /* granted */);
 #endif
 }
 
 void ProxyDecryptor::OnPermissionStatus(
     MediaKeys::SessionType session_type,
     EmeInitDataType init_data_type,
-    const std::vector<uint8>& init_data,
+    const std::vector<uint8_t>& init_data,
     scoped_ptr<NewSessionCdmPromise> promise,
     bool granted) {
   // ProxyDecryptor is only used by Prefixed EME, where RequestPermission() is
   // only for triggering the permission UI. Later CheckPermission() will be
   // called (e.g. in PlatformVerificationFlow on ChromeOS; in BrowserCdmManager
   // on Android) and the permission status will be evaluated then.
   DVLOG_IF(1, !granted) << "Permission request rejected.";
 
   media_keys_->CreateSessionAndGenerateRequest(session_type, init_data_type,
                                                init_data, promise.Pass());
 }
 
-void ProxyDecryptor::AddKey(const uint8* key,
+void ProxyDecryptor::AddKey(const uint8_t* key,
                             int key_length,
-                            const uint8* init_data,
+                            const uint8_t* init_data,
                             int init_data_length,
                             const std::string& session_id) {
   DVLOG(1) << "AddKey()";
 
   if (!media_keys_) {
     OnLegacySessionError(std::string(), MediaKeys::INVALID_STATE_ERROR, 0,
                          "CDM is not available.");
     return;
   }
 
@@ skipping 18 matching lines @@
                  weak_ptr_factory_.GetWeakPtr(), session_id)));
 
   // EME WD spec only supports a single array passed to the CDM. For
   // Clear Key using v0.1b, both arrays are used (|init_data| is key_id).
   // Since the EME WD spec supports the key as a JSON Web Key,
   // convert the 2 arrays to a JWK and pass it as the single array.
   if (is_clear_key_) {
     // Decryptor doesn't support empty key ID (see http://crbug.com/123265).
     // So ensure a non-empty value is passed.
     if (!init_data) {
-      static const uint8 kDummyInitData[1] = {0};
+      static const uint8_t kDummyInitData[1] = {0};
       init_data = kDummyInitData;
       init_data_length = arraysize(kDummyInitData);
     }
 
     std::string jwk =
         GenerateJWKSet(key, key_length, init_data, init_data_length);
     DCHECK(!jwk.empty());
     media_keys_->UpdateSession(new_session_id,
                                std::vector<uint8_t>(jwk.begin(), jwk.end()),
                                promise.Pass());
@@ skipping 17 matching lines @@
   scoped_ptr<SimpleCdmPromise> promise(new CdmCallbackPromise<>(
       base::Bind(&ProxyDecryptor::OnSessionClosed,
                  weak_ptr_factory_.GetWeakPtr(), session_id),
       base::Bind(&ProxyDecryptor::OnLegacySessionError,
                  weak_ptr_factory_.GetWeakPtr(), session_id)));
   media_keys_->RemoveSession(session_id, promise.Pass());
 }
 
 void ProxyDecryptor::OnSessionMessage(const std::string& session_id,
                                       MediaKeys::MessageType message_type,
-                                      const std::vector<uint8>& message,
+                                      const std::vector<uint8_t>& message,
                                       const GURL& legacy_destination_url) {
   // Assumes that OnSessionCreated() has been called before this.
 
   // For ClearKey, convert the message from JSON into just passing the key
   // as the message. If unable to extract the key, return the message unchanged.
   if (is_clear_key_) {
-    std::vector<uint8> key;
+    std::vector<uint8_t> key;
     if (ExtractFirstKeyIdFromLicenseRequest(message, &key)) {
       key_message_cb_.Run(session_id, key, legacy_destination_url);
       return;
     }
   }
 
   key_message_cb_.Run(session_id, message, legacy_destination_url);
 }
 
 void ProxyDecryptor::OnSessionKeysChange(const std::string& session_id,
@@ skipping 32 matching lines @@
   if (it->second) {
     OnLegacySessionError(session_id, MediaKeys::NOT_SUPPORTED_ERROR,
                          kSessionClosedSystemCode,
                          "Do not close persistent sessions.");
   }
   active_sessions_.erase(it);
 }
 
 void ProxyDecryptor::OnLegacySessionError(const std::string& session_id,
                                           MediaKeys::Exception exception_code,
-                                          uint32 system_code,
+                                          uint32_t system_code,
                                           const std::string& error_message) {
   // Convert |error_name| back to MediaKeys::KeyError if possible. Prefixed
   // EME has different error message, so all the specific error events will
   // get lost.
   MediaKeys::KeyError error_code;
   switch (exception_code) {
     case MediaKeys::CLIENT_ERROR:
       error_code = MediaKeys::kClientError;
       break;
     case MediaKeys::OUTPUT_ERROR:
@@ skipping 22 matching lines @@
   bool is_persistent =
       session_type == PersistentSession || session_type == LoadSession;
   active_sessions_.insert(std::make_pair(session_id, is_persistent));
 
   // For LoadSession(), generate the KeyAdded event.
   if (session_type == LoadSession)
     GenerateKeyAdded(session_id);
 }
 
 }  // namespace media