Switch to standard integer types in content/renderer/.

content/renderer/renderer_blink_platform_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/renderer_blink_platform_impl.h"
 
 #include "base/command_line.h"
 #include "base/files/file_path.h"
 #include "base/lazy_instance.h"
 #include "base/location.h"
@@ skipping 193 matching lines @@
 
 #if !defined(OS_ANDROID) && !defined(OS_WIN)
 class RendererBlinkPlatformImpl::SandboxSupport
     : public blink::WebSandboxSupport {
  public:
   virtual ~SandboxSupport() {}
 
 #if defined(OS_MACOSX)
   bool loadFont(NSFont* src_font,
                 CGFontRef* container,
-                uint32* font_id) override;
+                uint32_t* font_id) override;
 #elif defined(OS_POSIX)
   void getFallbackFontForCharacter(
       blink::WebUChar32 character,
       const char* preferred_locale,
       blink::WebFallbackFont* fallbackFont) override;
   void getRenderStyleForStrike(const char* family,
                                int sizeAndStyle,
                                blink::WebFontRenderStyle* out) override;
 
  private:
@@ skipping 155 matching lines @@
   WebMessagePortChannelImpl::CreatePair(
       default_task_runner_, channel1, channel2);
 }
 
 blink::WebPrescientNetworking*
 RendererBlinkPlatformImpl::prescientNetworking() {
   return GetContentClient()->renderer()->GetPrescientNetworking();
 }
 
 void RendererBlinkPlatformImpl::cacheMetadata(const blink::WebURL& url,
-                                              int64 response_time,
+                                              int64_t response_time,
                                               const char* data,
                                               size_t size) {
   // Let the browser know we generated cacheable metadata for this resource. The
   // browser may cache it and return it on subsequent responses to speed
   // the processing of this resource.
   std::vector<char> copy(data, data + size);
   RenderThread::Get()->Send(
       new RenderProcessHostMsg_DidGenerateCacheableMetadata(
           url, base::Time::FromInternalValue(response_time), copy));
 }
@@ skipping 136 matching lines @@
   UMA_HISTOGRAM_TIMES("RendererSyncIPC.ElapsedTime", delta);
   return success;
 }
 
 //------------------------------------------------------------------------------
 
 #if defined(OS_MACOSX)
 
 bool RendererBlinkPlatformImpl::SandboxSupport::loadFont(NSFont* src_font,
                                                          CGFontRef* out,
-                                                         uint32* font_id) {
-  uint32 font_data_size;
+                                                         uint32_t* font_id) {
+  uint32_t font_data_size;
   FontDescriptor src_font_descriptor(src_font);
   base::SharedMemoryHandle font_data;
   if (!RenderThread::Get()->Send(new RenderProcessHostMsg_LoadFont(
         src_font_descriptor, &font_data_size, &font_data, font_id))) {
     *out = NULL;
     *font_id = 0;
     return false;
   }
 
   if (font_data_size == 0 || font_data == base::SharedMemory::NULLHandle() ||
@@ skipping 257 matching lines @@
 }
 
 //------------------------------------------------------------------------------
 
 blink::WebString RendererBlinkPlatformImpl::signedPublicKeyAndChallengeString(
     unsigned key_size_index,
     const blink::WebString& challenge,
     const blink::WebURL& url) {
   std::string signed_public_key;
   RenderThread::Get()->Send(new RenderProcessHostMsg_Keygen(
-      static_cast<uint32>(key_size_index),
-      challenge.utf8(),
-      GURL(url),
+      static_cast<uint32_t>(key_size_index), challenge.utf8(), GURL(url),
       &signed_public_key));
   return WebString::fromUTF8(signed_public_key);
 }
 
 //------------------------------------------------------------------------------
 
 void RendererBlinkPlatformImpl::screenColorProfile(
     WebVector<char>* to_profile) {
 #if defined(OS_WIN)
   // On Windows screen color profile is only available in the browser.
@@ skipping 272 matching lines @@
 // static
 void RendererBlinkPlatformImpl::SetMockDeviceOrientationDataForTesting(
     const blink::WebDeviceOrientationData& data) {
   g_test_device_orientation_data.Get() = data;
 }
 
 //------------------------------------------------------------------------------
 
 void RendererBlinkPlatformImpl::vibrate(unsigned int milliseconds) {
   GetConnectedVibrationManagerService()->Vibrate(
-      base::checked_cast<int64>(milliseconds));
+      base::checked_cast<int64_t>(milliseconds));
   vibration_manager_.reset();
 }
 
 void RendererBlinkPlatformImpl::cancelVibration() {
   GetConnectedVibrationManagerService()->Cancel();
   vibration_manager_.reset();
 }
 
 device::VibrationManagerPtr&
 RendererBlinkPlatformImpl::GetConnectedVibrationManagerService() {
@@ skipping 64 matching lines @@
           static_cast<blink::WebBatteryStatusListener*>(listener)));
     }
     return;
   }
 
   PlatformEventObserverBase* observer = platform_event_observers_.Lookup(type);
   if (!observer) {
     observer = CreatePlatformEventObserverFromType(type);
     if (!observer)
       return;
-    platform_event_observers_.AddWithID(observer, static_cast<int32>(type));
+    platform_event_observers_.AddWithID(observer, static_cast<int32_t>(type));
   }
   observer->Start(listener);
 
   // Device events (motion, orientation and light) expect to get an event fired
   // as soon as a listener is registered if a fake data was passed before.
   // TODO(mlamouri,timvolodine): make those send mock values directly instead of
   // using this broken pattern.
   if (RenderThreadImpl::current() &&
       RenderThreadImpl::current()->layout_test_mode() &&
       (type == blink::WebPlatformEventTypeDeviceMotion ||
@@ skipping 71 matching lines @@
 //------------------------------------------------------------------------------
 
 void RendererBlinkPlatformImpl::MockBatteryStatusChangedForTesting(
     const blink::WebBatteryStatus& status) {
   if (!g_test_battery_status_listener)
     return;
   g_test_battery_status_listener->updateBatteryStatus(status);
 }
 
 }  // namespace content