Switch to standard integer types in pdf/.

pdf/out_of_process_instance.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 "pdf/out_of_process_instance.h"
 
+#include <stddef.h>
+#include <stdint.h>
+
 #include <algorithm>  // for min/max()
 #define _USE_MATH_DEFINES  // for M_PI
 #include <cmath>      // for log() and pow()
 #include <math.h>
 #include <list>
 
 #include "base/json/json_reader.h"
 #include "base/json/json_writer.h"
 #include "base/logging.h"
 #include "base/strings/string_number_conversions.h"
@@ skipping 792 matching lines @@
 
 int OutOfProcessInstance::GetDocumentPixelWidth() const {
   return static_cast<int>(ceil(document_size_.width() * zoom_ * device_scale_));
 }
 
 int OutOfProcessInstance::GetDocumentPixelHeight() const {
   return static_cast<int>(
       ceil(document_size_.height() * zoom_ * device_scale_));
 }
 
-void OutOfProcessInstance::FillRect(const pp::Rect& rect, uint32 color) {
+void OutOfProcessInstance::FillRect(const pp::Rect& rect, uint32_t color) {
   DCHECK(!image_data_.is_null() || rect.IsEmpty());
-  uint32* buffer_start = static_cast<uint32*>(image_data_.data());
+  uint32_t* buffer_start = static_cast<uint32_t*>(image_data_.data());
   int stride = image_data_.stride();
-  uint32* ptr = buffer_start + rect.y() * stride / 4 + rect.x();
+  uint32_t* ptr = buffer_start + rect.y() * stride / 4 + rect.x();
   int height = rect.height();
   int width = rect.width();
   for (int y = 0; y < height; ++y) {
     for (int x = 0; x < width; ++x)
       *(ptr + x) = color;
     ptr += stride /4;
   }
 }
 
 void OutOfProcessInstance::DocumentSizeUpdated(const pp::Size& size) {
@@ skipping 411 matching lines @@
   if (!full_)
     return;
 
   if (told_browser_about_unsupported_feature_)
     return;
   told_browser_about_unsupported_feature_ = true;
 
   pp::PDF::HasUnsupportedFeature(this);
 }
 
-void OutOfProcessInstance::DocumentLoadProgress(uint32 available,
-                                                uint32 doc_size) {
+void OutOfProcessInstance::DocumentLoadProgress(uint32_t available,
+                                                uint32_t doc_size) {
   double progress = 0.0;
   if (doc_size == 0) {
     // Document size is unknown. Use heuristics.
     // We'll make progress logarithmic from 0 to 100M.
     static const double kFactor = log(100000000.0) / 100.0;
     if (available > 0) {
       progress = log(static_cast<double>(available)) / kFactor;
       if (progress > 100.0)
         progress = 100.0;
     }
@@ skipping 106 matching lines @@
     return;
   engine_->AppendBlankPages(print_preview_page_count_);
   if (!preview_pages_info_.empty())
     LoadAvailablePreviewPage();
 }
 
 bool OutOfProcessInstance::IsPrintPreview() {
   return IsPrintPreviewUrl(url_);
 }
 
-uint32 OutOfProcessInstance::GetBackgroundColor() {
+uint32_t OutOfProcessInstance::GetBackgroundColor() {
   return background_color_;
 }
 
 void OutOfProcessInstance::IsSelectingChanged(bool is_selecting) {
   pp::VarDictionary message;
   message.Set(kType, kJSSetIsSelectingType);
   message.Set(kJSIsSelecting, pp::Var(is_selecting));
   PostMessage(message);
 }
 
@@ skipping 39 matching lines @@
     const pp::FloatPoint& scroll_offset) {
   float max_x = document_size_.width() * zoom_ - plugin_dip_size_.width();
   float x = std::max(std::min(scroll_offset.x(), max_x), 0.0f);
   float min_y = -top_toolbar_height_;
   float max_y = document_size_.height() * zoom_ - plugin_dip_size_.height();
   float y = std::max(std::min(scroll_offset.y(), max_y), min_y);
   return pp::FloatPoint(x, y);
 }
 
 }  // namespace chrome_pdf