Switch to standard integer types in content/renderer/.

content/renderer/npapi/webplugin_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/npapi/webplugin_impl.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/debug/crash_logging.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/memory/linked_ptr.h"
 #include "base/metrics/user_metrics_action.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/thread_task_runner_handle.h"
+#include "build/build_config.h"
 #include "cc/blink/web_layer_impl.h"
 #include "cc/layers/io_surface_layer.h"
 #include "content/child/appcache/web_application_cache_host_impl.h"
 #include "content/child/multipart_response_delegate.h"
 #include "content/child/npapi/plugin_host.h"
 #include "content/child/npapi/plugin_instance.h"
 #include "content/child/npapi/webplugin_delegate_impl.h"
 #include "content/child/npapi/webplugin_resource_client.h"
 #include "content/common/view_messages.h"
 #include "content/public/common/content_constants.h"
@@ skipping 77 matching lines @@
                           WebURLRequest&,
                           const WebURLResponse&) override {}
   void didSendData(WebURLLoader*,
                    unsigned long long,
                    unsigned long long) override {}
 
   // Called when the multipart parser encounters an embedded multipart
   // response.
   void didReceiveResponse(WebURLLoader*,
                           const WebURLResponse& response) override {
-    int64 byte_range_upper_bound, instance_size;
+    int64_t byte_range_upper_bound, instance_size;
     if (!MultipartResponseDelegate::ReadContentRanges(
             response,
             &byte_range_lower_bound_,
             &byte_range_upper_bound,
             &instance_size)) {
       NOTREACHED();
     }
   }
 
   // Receives individual part data from a multipart response.
   void didReceiveData(WebURLLoader*,
                       const char* data,
                       int data_length,
                       int encoded_data_length) override {
     // TODO(ananta)
     // We should defer further loads on multipart resources on the same lines
     // as regular resources requested by plugins to prevent reentrancy.
     resource_client_->DidReceiveData(
         data, data_length, byte_range_lower_bound_);
     byte_range_lower_bound_ += data_length;
   }
 
   void didFinishLoading(WebURLLoader*,
                         double finishTime,
                         int64_t total_encoded_data_length) override {}
   void didFail(WebURLLoader*, const WebURLError&) override {}
 
  private:
   // The lower bound of the byte range.
-  int64 byte_range_lower_bound_;
+  int64_t byte_range_lower_bound_;
   // The handler for the data.
   WebPluginResourceClient* resource_client_;
 };
 
 class HeaderFlattener : public WebHTTPHeaderVisitor {
  public:
   explicit HeaderFlattener(std::string* buf) : buf_(buf) {
   }
 
   void visitHeader(const WebString& name, const WebString& value) override {
@@ skipping 25 matching lines @@
 
   HeaderFlattener flattener(&result);
   response.visitHTTPHeaderFields(&flattener);
 
   return result;
 }
 
 struct ResponseInfo {
   GURL url;
   std::string mime_type;
-  uint32 last_modified;
-  uint32 expected_length;
+  uint32_t last_modified;
+  uint32_t expected_length;
 };
 
 void GetResponseInfo(const WebURLResponse& response,
                      ResponseInfo* response_info) {
   response_info->url = response.url();
   response_info->mime_type = response.mimeType().utf8();
 
   // Measured in seconds since 12:00 midnight GMT, January 1, 1970.
   response_info->last_modified =
-      static_cast<uint32>(response.lastModifiedDate());
+      static_cast<uint32_t>(response.lastModifiedDate());
 
   // If the length comes in as -1, then it indicates that it was not
   // read off the HTTP headers. We replicate Safari webkit behavior here,
   // which is to set it to 0.
   response_info->expected_length =
-      static_cast<uint32>(std::max(response.expectedContentLength(), 0LL));
+      static_cast<uint32_t>(std::max(response.expectedContentLength(), 0LL));
 
   WebString content_encoding =
       response.httpHeaderField(WebString::fromUTF8("Content-Encoding"));
   if (!content_encoding.isNull() &&
       !base::EqualsASCII(base::StringPiece16(content_encoding), "identity")) {
     // Don't send the compressed content length to the plugin, which only
     // cares about the decoded length.
     response_info->expected_length = 0;
   }
 }
 
 }  // namespace
 
 // blink::WebPlugin ----------------------------------------------------------
 
 struct WebPluginImpl::ClientInfo {
   unsigned long id;
   WebPluginResourceClient* client;
   blink::WebURLRequest request;
   bool pending_failure_notification;
   linked_ptr<blink::WebURLLoader> loader;
   bool notify_redirects;
   bool is_plugin_src_load;
-  int64 data_offset;
+  int64_t data_offset;
 };
 
 bool WebPluginImpl::initialize(WebPluginContainer* container) {
   if (!render_view_.get()) {
     LOG(ERROR) << "No RenderView";
     return false;
   }
 
   WebPluginDelegateProxy* plugin_delegate = new WebPluginDelegateProxy(
       this, mime_type_, render_view_, render_frame_);
@@ skipping 317 matching lines @@
         clients_[i].loader->setDefersLoading(false);
         clients_[i].loader->cancel();
         RemoveClient(i);
       }
       return;
     }
   }
 }
 
 bool WebPluginImpl::SetPostData(WebURLRequest* request,
-                                const char *buf,
-                                uint32 length) {
+                                const char* buf,
+                                uint32_t length) {
   std::vector<std::string> names;
   std::vector<std::string> values;
   std::vector<char> body;
   bool rv = PluginHost::SetPostData(buf, length, &names, &values, &body);
 
   for (size_t i = 0; i < names.size(); ++i) {
     request->addHTTPHeaderField(WebString::fromUTF8(names[i]),
                                 WebString::fromUTF8(values[i]));
   }
 
@@ skipping 188 matching lines @@
 
 #if defined(OS_MACOSX)
 WebPluginAcceleratedSurface* WebPluginImpl::GetAcceleratedSurface(
     gfx::GpuPreference gpu_preference) {
   return NULL;
 }
 
 void WebPluginImpl::AcceleratedPluginEnabledRendering() {
 }
 
-void WebPluginImpl::AcceleratedPluginAllocatedIOSurface(int32 width,
-                                                        int32 height,
-                                                        uint32 surface_id) {
+void WebPluginImpl::AcceleratedPluginAllocatedIOSurface(int32_t width,
+                                                        int32_t height,
+                                                        uint32_t surface_id) {
   next_io_surface_allocated_ = true;
   next_io_surface_width_ = width;
   next_io_surface_height_ = height;
   next_io_surface_id_ = surface_id;
 }
 
 void WebPluginImpl::AcceleratedPluginSwappedIOSurface() {
   if (!container_)
     return;
   // Deferring the call to setBackingIOSurfaceId is an attempt to
@@ skipping 424 matching lines @@
     case PLUGIN_SRC:
       webframe_->setReferrerForRequest(*request, plugin_url_);
       break;
 
     default:
       break;
   }
 }
 
 }  // namespace content