Switch to standard integer types in content/renderer/.

content/renderer/pepper/pepper_plugin_instance_impl.cc

 // Copyright (c) 2012 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/pepper/pepper_plugin_instance_impl.h"
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
 #include "base/single_thread_task_runner.h"
 #include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_offset_string_conversions.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/time/time.h"
 #include "base/trace_event/trace_event.h"
+#include "build/build_config.h"
 #include "cc/blink/web_layer_impl.h"
 #include "cc/layers/texture_layer.h"
 #include "content/common/content_constants_internal.h"
 #include "content/common/frame_messages.h"
 #include "content/public/common/content_constants.h"
 #include "content/public/renderer/content_renderer_client.h"
 #include "content/renderer/pepper/content_decryptor_delegate.h"
 #include "content/renderer/pepper/event_conversion.h"
 #include "content/renderer/pepper/fullscreen_container.h"
 #include "content/renderer/pepper/gfx_conversion.h"
@@ skipping 729 matching lines @@
       // incompatible with the move and backfill scrolling model.
       InvalidateRect(rect);
     }
   }
 }
 
 void PepperPluginInstanceImpl::CommitBackingTexture() {
   if (!texture_layer_.get())
     return;
   gpu::Mailbox mailbox;
-  uint32 sync_point = 0;
+  uint32_t sync_point = 0;
   bound_graphics_3d_->GetBackingMailbox(&mailbox, &sync_point);
   DCHECK(!mailbox.IsZero());
   DCHECK_NE(sync_point, 0u);
   texture_layer_->SetTextureMailboxWithoutReleaseCallback(
       cc::TextureMailbox(mailbox, gpu::SyncToken(sync_point), GL_TEXTURE_2D));
   texture_layer_->SetNeedsDisplay();
 }
 
 void PepperPluginInstanceImpl::InstanceCrashed() {
   // Force free all resources and vars.
@@ skipping 1170 matching lines @@
   NOTREACHED();
 #endif  // ENABLE_PRINTING
   return false;
 }
 
 void PepperPluginInstanceImpl::UpdateLayer(bool device_changed) {
   if (!container_)
     return;
 
   gpu::Mailbox mailbox;
-  uint32 sync_point = 0;
+  uint32_t sync_point = 0;
   if (bound_graphics_3d_.get()) {
     bound_graphics_3d_->GetBackingMailbox(&mailbox, &sync_point);
     DCHECK_EQ(mailbox.IsZero(), sync_point == 0);
   }
   bool want_3d_layer = !mailbox.IsZero();
   bool want_2d_layer = !!bound_graphics_2d_platform_;
   bool want_texture_layer = want_3d_layer || want_2d_layer;
   bool want_compositor_layer = !!bound_compositor_;
 
   if (throttler_ && throttler_->IsHiddenForPlaceholder()) {
@@ skipping 412 matching lines @@
     return PP_MakeUndefined();
   return StringVar::StringToPPVar(
       render_frame_->render_view()->webkit_preferences().default_encoding);
 }
 
 // These PPB_ContentDecryptor_Private calls are responses to
 // PPP_ContentDecryptor_Private calls made on |content_decryptor_delegate_|.
 // Therefore, |content_decryptor_delegate_| must have been initialized when
 // the following methods are called.
 void PepperPluginInstanceImpl::PromiseResolved(PP_Instance instance,
-                                               uint32 promise_id) {
+                                               uint32_t promise_id) {
   content_decryptor_delegate_->OnPromiseResolved(promise_id);
 }
 
 void PepperPluginInstanceImpl::PromiseResolvedWithSession(
     PP_Instance instance,
-    uint32 promise_id,
+    uint32_t promise_id,
     PP_Var session_id_var) {
   content_decryptor_delegate_->OnPromiseResolvedWithSession(promise_id,
                                                             session_id_var);
 }
 
 void PepperPluginInstanceImpl::PromiseRejected(
     PP_Instance instance,
-    uint32 promise_id,
+    uint32_t promise_id,
     PP_CdmExceptionCode exception_code,
-    uint32 system_code,
+    uint32_t system_code,
     PP_Var error_description_var) {
   content_decryptor_delegate_->OnPromiseRejected(
       promise_id, exception_code, system_code, error_description_var);
 }
 
 void PepperPluginInstanceImpl::SessionMessage(PP_Instance instance,
                                               PP_Var session_id_var,
                                               PP_CdmMessageType message_type,
                                               PP_Var message_var,
                                               PP_Var legacy_destination_url) {
@@ skipping 21 matching lines @@
 
 void PepperPluginInstanceImpl::SessionClosed(PP_Instance instance,
                                              PP_Var session_id_var) {
   content_decryptor_delegate_->OnSessionClosed(session_id_var);
 }
 
 void PepperPluginInstanceImpl::LegacySessionError(
     PP_Instance instance,
     PP_Var session_id_var,
     PP_CdmExceptionCode exception_code,
-    uint32 system_code,
+    uint32_t system_code,
     PP_Var error_description_var) {
   content_decryptor_delegate_->OnLegacySessionError(
       session_id_var, exception_code, system_code, error_description_var);
 }
 
 void PepperPluginInstanceImpl::DeliverBlock(
     PP_Instance instance,
     PP_Resource decrypted_block,
     const PP_DecryptedBlockInfo* block_info) {
   content_decryptor_delegate_->DeliverBlock(decrypted_block, block_info);
@@ skipping 70 matching lines @@
 }
 
 void PepperPluginInstanceImpl::SetTickmarks(PP_Instance instance,
                                             const PP_Rect* tickmarks,
                                             uint32_t count) {
   if (!render_frame_ || !render_frame_->GetWebFrame())
     return;
 
   blink::WebVector<blink::WebRect> tickmarks_converted(
       static_cast<size_t>(count));
-  for (uint32 i = 0; i < count; ++i) {
+  for (uint32_t i = 0; i < count; ++i) {
     tickmarks_converted[i] = blink::WebRect(tickmarks[i].point.x,
                                             tickmarks[i].point.y,
                                             tickmarks[i].size.width,
                                             tickmarks[i].size.height);
   }
   blink::WebFrame* frame = render_frame_->GetWebFrame();
   frame->setTickmarks(tickmarks_converted);
 }
 
 PP_Bool PepperPluginInstanceImpl::IsFullscreen(PP_Instance instance) {
@@ skipping 720 matching lines @@
 
 void PepperPluginInstanceImpl::RecordFlashJavaScriptUse() {
   if (initialized_ && !javascript_used_ && is_flash_plugin_) {
     javascript_used_ = true;
     RenderThread::Get()->RecordAction(
         base::UserMetricsAction("Flash.JavaScriptUsed"));
   }
 }
 
 }  // namespace content