Switch to standard integer types in content/renderer/.

content/renderer/media/android/webmediaplayer_android.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 "content/renderer/media/android/webmediaplayer_android.h"
 
+#include <stddef.h>
+
 #include <limits>
 
 #include "base/android/build_info.h"
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/command_line.h"
 #include "base/files/file_path.h"
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
 #include "base/single_thread_task_runner.h"
@@ skipping 42 matching lines @@
 #include "third_party/WebKit/public/web/WebRuntimeFeatures.h"
 #include "third_party/WebKit/public/web/WebSecurityOrigin.h"
 #include "third_party/WebKit/public/web/WebView.h"
 #include "third_party/skia/include/core/SkCanvas.h"
 #include "third_party/skia/include/core/SkPaint.h"
 #include "third_party/skia/include/core/SkTypeface.h"
 #include "third_party/skia/include/gpu/GrContext.h"
 #include "third_party/skia/include/gpu/SkGrPixelRef.h"
 #include "ui/gfx/image/image.h"
 
-static const uint32 kGLTextureExternalOES = 0x8D65;
+static const uint32_t kGLTextureExternalOES = 0x8D65;
 static const int kSDKVersionToSupportSecurityOriginCheck = 20;
 
 using blink::WebMediaPlayer;
 using blink::WebSize;
 using blink::WebString;
 using blink::WebURL;
 using gpu::gles2::GLES2Interface;
 using media::LogHelper;
 using media::MediaLog;
 using media::MediaPlayerAndroid;
@@ skipping 10 matching lines @@
   PREDICTION_RESULT_ALL_INCORRECT,
   PREDICTION_RESULT_PATH_BASED_WAS_BETTER,
   PREDICTION_RESULT_URL_BASED_WAS_BETTER,
   // Must always be larger than the largest logged value.
   PREDICTION_RESULT_MAX
 };
 
 // File-static function is to allow it to run even after WMPA is deleted.
 void OnReleaseTexture(
     const scoped_refptr<content::StreamTextureFactory>& factories,
-    uint32 texture_id,
+    uint32_t texture_id,
     const gpu::SyncToken& sync_token) {
   GLES2Interface* gl = factories->ContextGL();
   gl->WaitSyncTokenCHROMIUM(sync_token.GetConstData());
   gl->DeleteTextures(1, &texture_id);
   // Flush to ensure that the stream texture gets deleted in a timely fashion.
   gl->ShallowFlushCHROMIUM();
 }
 
 bool IsSkBitmapProperlySizedTexture(const SkBitmap* bitmap,
                                     const gfx::Size& size) {
@@ skipping 586 matching lines @@
   const gpu::MailboxHolder& mailbox_holder = video_frame->mailbox_holder(0);
   DCHECK((!is_remote_ &&
           mailbox_holder.texture_target == GL_TEXTURE_EXTERNAL_OES) ||
          (is_remote_ && mailbox_holder.texture_target == GL_TEXTURE_2D));
 
   web_graphics_context->waitSyncTokenCHROMIUM(
       mailbox_holder.sync_token.GetConstData());
 
   // Ensure the target of texture is set before copyTextureCHROMIUM, otherwise
   // an invalid texture target may be used for copy texture.
-  uint32 src_texture =
-      web_graphics_context->createAndConsumeTextureCHROMIUM(
-          mailbox_holder.texture_target, mailbox_holder.mailbox.name);
+  uint32_t src_texture = web_graphics_context->createAndConsumeTextureCHROMIUM(
+      mailbox_holder.texture_target, mailbox_holder.mailbox.name);
 
   // Application itself needs to take care of setting the right flip_y
   // value down to get the expected result.
   // flip_y==true means to reverse the video orientation while
   // flip_y==false means to keep the intrinsic orientation.
   web_graphics_context->copyTextureCHROMIUM(
       GL_TEXTURE_2D, src_texture, texture, internal_format, type,
       flip_y, premultiply_alpha, false);
 
   web_graphics_context->deleteTexture(src_texture);
@@ skipping 1038 matching lines @@
 void WebMediaPlayerAndroid::OnKeyAdded(const std::string& session_id) {
   EmeUMAHistogramCounts(current_key_system_, "KeyAdded", 1);
 
   encrypted_client_->keyAdded(
       WebString::fromUTF8(media::GetPrefixedKeySystemName(current_key_system_)),
       WebString::fromUTF8(session_id));
 }
 
 void WebMediaPlayerAndroid::OnKeyError(const std::string& session_id,
                                        media::MediaKeys::KeyError error_code,
-                                       uint32 system_code) {
+                                       uint32_t system_code) {
   EmeUMAHistogramEnumeration(current_key_system_, "KeyError",
                              error_code, media::MediaKeys::kMaxKeyError);
 
   unsigned short short_system_code = 0;
   if (system_code > std::numeric_limits<unsigned short>::max()) {
     LOG(WARNING) << "system_code exceeds unsigned short limit.";
     short_system_code = std::numeric_limits<unsigned short>::max();
   } else {
     short_system_code = static_cast<unsigned short>(system_code);
   }
 
   encrypted_client_->keyError(
       WebString::fromUTF8(media::GetPrefixedKeySystemName(current_key_system_)),
       WebString::fromUTF8(session_id),
       static_cast<blink::WebMediaPlayerEncryptedMediaClient::MediaKeyErrorCode>(
           error_code),
       short_system_code);
 }
 
 void WebMediaPlayerAndroid::OnKeyMessage(const std::string& session_id,
-                                         const std::vector<uint8>& message,
+                                         const std::vector<uint8_t>& message,
                                          const GURL& destination_url) {
   DCHECK(destination_url.is_empty() || destination_url.is_valid());
 
   encrypted_client_->keyMessage(
       WebString::fromUTF8(media::GetPrefixedKeySystemName(current_key_system_)),
       WebString::fromUTF8(session_id), message.empty() ? NULL : &message[0],
       message.size(), destination_url);
 }
 
 void WebMediaPlayerAndroid::OnMediaSourceOpened(
     blink::WebMediaSource* web_media_source) {
   client_->mediaSourceOpened(web_media_source);
 }
 
 void WebMediaPlayerAndroid::OnEncryptedMediaInitData(
     media::EmeInitDataType init_data_type,
-    const std::vector<uint8>& init_data) {
+    const std::vector<uint8_t>& init_data) {
   DCHECK(main_thread_checker_.CalledOnValidThread());
 
   // Do not fire NeedKey event if encrypted media is not enabled.
   if (!blink::WebRuntimeFeatures::isPrefixedEncryptedMediaEnabled() &&
       !blink::WebRuntimeFeatures::isEncryptedMediaEnabled()) {
     return;
   }
 
   UMA_HISTOGRAM_COUNTS(kMediaEme + std::string("NeedKey"), 1);
 
@@ skipping 156 matching lines @@
     result = PREDICTION_RESULT_PATH_BASED_WAS_BETTER;
   } else if (is_hls_url == is_hls) {
     result = PREDICTION_RESULT_URL_BASED_WAS_BETTER;
   }
   UMA_HISTOGRAM_ENUMERATION(
       "Media.Android.IsHttpLiveStreamingMediaPredictionResult",
       result, PREDICTION_RESULT_MAX);
 }
 
 }  // namespace content