Switch to standard integer types in content/renderer/.

content/renderer/npapi/webplugin_delegate_proxy.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/npapi/webplugin_delegate_proxy.h"
 
+#include <stddef.h>
+
 #include <algorithm>
 
 #include "base/auto_reset.h"
-#include "base/basictypes.h"
 #include "base/command_line.h"
 #include "base/files/file_util.h"
 #include "base/logging.h"
+#include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/process/process.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/version.h"
+#include "build/build_config.h"
 #include "cc/resources/shared_bitmap.h"
 #include "content/child/child_process.h"
 #include "content/child/child_shared_bitmap_manager.h"
 #include "content/child/npapi/npobject_proxy.h"
 #include "content/child/npapi/npobject_stub.h"
 #include "content/child/npapi/npobject_util.h"
 #include "content/child/npapi/webplugin_resource_client.h"
 #include "content/child/plugin_messages.h"
 #include "content/common/content_constants_internal.h"
 #include "content/common/cursors/webcursor.h"
@@ skipping 72 matching lines @@
 
   // PluginResourceClient implementation:
   void WillSendRequest(const GURL& url, int http_status_code) override {
     DCHECK(channel_.get() != NULL);
     channel_->Send(new PluginMsg_WillSendRequest(
         instance_id_, resource_id_, url, http_status_code));
   }
 
   void DidReceiveResponse(const std::string& mime_type,
                           const std::string& headers,
-                          uint32 expected_length,
-                          uint32 last_modified,
+                          uint32_t expected_length,
+                          uint32_t last_modified,
                           bool request_is_seekable) override {
     DCHECK(channel_.get() != NULL);
     PluginMsg_DidReceiveResponseParams params;
     params.id = resource_id_;
     params.mime_type = mime_type;
     params.headers = headers;
     params.expected_length = expected_length;
     params.last_modified = last_modified;
     params.request_is_seekable = request_is_seekable;
     // Grab a reference on the underlying channel so it does not get
@@ skipping 361 matching lines @@
   }
 
   Send(msg);
 }
 
 void WebPluginDelegateProxy::UpdateGeometry(const gfx::Rect& window_rect,
                                             const gfx::Rect& clip_rect) {
   // window_rect becomes either a window in native windowing system
   // coords, or a backing buffer.  In either case things will go bad
   // if the rectangle is very large.
-  if (window_rect.width() < 0  || window_rect.width() > kMaxPluginSideLength ||
+  if (window_rect.width() < 0 || window_rect.width() > kMaxPluginSideLength ||
       window_rect.height() < 0 || window_rect.height() > kMaxPluginSideLength ||
       // We know this won't overflow due to above checks.
-      static_cast<uint32>(window_rect.width()) *
-          static_cast<uint32>(window_rect.height()) > kMaxPluginSize) {
+      static_cast<uint32_t>(window_rect.width()) *
+              static_cast<uint32_t>(window_rect.height()) >
+          kMaxPluginSize) {
     return;
   }
 
   plugin_rect_ = window_rect;
   clip_rect_ = clip_rect;
 
   bool bitmaps_changed = false;
 
   if (uses_shared_bitmaps_) {
     if (!front_buffer_canvas() ||
@@ skipping 34 matching lines @@
 }
 
 #if !defined(OS_WIN)
 static size_t BitmapSizeForPluginRect(const gfx::Rect& plugin_rect) {
   const size_t stride =
       skia::PlatformCanvasStrideForWidth(plugin_rect.width());
   return stride * plugin_rect.height();
 }
 
 bool WebPluginDelegateProxy::CreateLocalBitmap(
-    std::vector<uint8>* memory,
+    std::vector<uint8_t>* memory,
     scoped_ptr<skia::PlatformCanvas>* canvas) {
   const size_t size = BitmapSizeForPluginRect(plugin_rect_);
   memory->resize(size);
   if (memory->size() != size)
     return false;
   canvas->reset(skia::CreatePlatformCanvas(
       plugin_rect_.width(), plugin_rect_.height(), true, &((*memory)[0]),
       skia::CRASH_ON_FAILURE));
   return true;
 }
@@ skipping 369 matching lines @@
 void WebPluginDelegateProxy::CopyFromBackBufferToFrontBuffer(
     const gfx::Rect& rect) {
 #if defined(OS_MACOSX)
   // Blitting the bits directly is much faster than going through CG, and since
   // the goal is just to move the raw pixels between two bitmaps with the same
   // pixel format (no compositing, color correction, etc.), it's safe.
   const size_t stride =
       skia::PlatformCanvasStrideForWidth(plugin_rect_.width());
   const size_t chunk_size = 4 * rect.width();
   DCHECK(back_buffer_bitmap() != NULL);
-  uint8* source_data =
+  uint8_t* source_data =
       back_buffer_bitmap()->pixels() + rect.y() * stride + 4 * rect.x();
   DCHECK(front_buffer_bitmap() != NULL);
-  uint8* target_data =
+  uint8_t* target_data =
       front_buffer_bitmap()->pixels() + rect.y() * stride + 4 * rect.x();
   for (int row = 0; row < rect.height(); ++row) {
     memcpy(target_data, source_data, chunk_size);
     source_data += stride;
     target_data += stride;
   }
 #else
   BlitCanvasToCanvas(front_buffer_canvas(),
                      rect,
                      back_buffer_canvas(),
@@ skipping 71 matching lines @@
   plugin_->SetDeferResourceLoading(resource_id, defer);
 }
 
 #if defined(OS_MACOSX)
 void WebPluginDelegateProxy::OnAcceleratedPluginEnabledRendering() {
   uses_compositor_ = true;
   OnSetWindow(gfx::kNullPluginWindow);
 }
 
 void WebPluginDelegateProxy::OnAcceleratedPluginAllocatedIOSurface(
-    int32 width,
-    int32 height,
-    uint32 surface_id) {
+    int32_t width,
+    int32_t height,
+    uint32_t surface_id) {
   if (plugin_)
     plugin_->AcceleratedPluginAllocatedIOSurface(width, height, surface_id);
 }
 
 void WebPluginDelegateProxy::OnAcceleratedPluginSwappedIOSurface() {
   if (plugin_)
     plugin_->AcceleratedPluginSwappedIOSurface();
 }
 #endif
 
@@ skipping 29 matching lines @@
 
   plugin_->URLRedirectResponse(allow, resource_id);
 }
 
 void WebPluginDelegateProxy::OnCheckIfRunInsecureContent(const GURL& url,
                                                          bool* result) {
   *result = plugin_->CheckIfRunInsecureContent(url);
 }
 
 }  // namespace content