Switch to standard integer types in chrome/.

chrome/utility/media_galleries/image_metadata_extractor.cc

 // Copyright 2014 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 "chrome/utility/media_galleries/image_metadata_extractor.h"
 
 extern "C" {
 #include <libexif/exif-data.h>
 #include <libexif/exif-loader.h>
 }  // extern "C"
+#include <stddef.h>
+#include <stdint.h>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/files/file_path.h"
 #include "base/lazy_instance.h"
+#include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/numerics/safe_conversions.h"
 #include "base/path_service.h"
 #include "base/scoped_native_library.h"
 #include "base/strings/string_number_conversions.h"
+#include "build/build_config.h"
 #include "content/public/common/content_paths.h"
 #include "media/base/data_source.h"
 #include "net/base/io_buffer.h"
 
 namespace metadata {
 
 namespace {
 
 const size_t kMaxBufferSize = 50 * 1024 * 1024;  // Arbitrary maximum of 50MB.
 
 typedef base::Callback<void(const scoped_refptr<net::DrainableIOBuffer>&)>
     GotImageCallback;
 
 void FinishGetImageBytes(
     const scoped_refptr<net::DrainableIOBuffer>& buffer,
     media::DataSource* source,
     const GotImageCallback& callback,
     int bytes_read) {
   if (bytes_read == media::DataSource::kReadError) {
     callback.Run(NULL);
     return;
   }
 
   buffer->DidConsume(bytes_read);
   // Didn't get the whole file. Continue reading to get the rest.
   if (buffer->BytesRemaining() > 0) {
-    source->Read(
-        0,
-        buffer->BytesRemaining(),
-        reinterpret_cast<uint8*>(buffer->data()),
-        base::Bind(
-            &FinishGetImageBytes, buffer, base::Unretained(source), callback));
+    source->Read(0, buffer->BytesRemaining(),
+                 reinterpret_cast<uint8_t*>(buffer->data()),
+                 base::Bind(&FinishGetImageBytes, buffer,
+                            base::Unretained(source), callback));
     return;
   }
 
   buffer->SetOffset(0);
   callback.Run(buffer);
 }
 
 void GetImageBytes(
     media::DataSource* source,
     const GotImageCallback& callback) {
-  int64 size64 = 0;
+  int64_t size64 = 0;
   if (!source->GetSize(&size64) ||
       base::saturated_cast<size_t>(size64) > kMaxBufferSize) {
     return callback.Run(NULL);
   }
   int size = base::checked_cast<int>(size64);
 
   scoped_refptr<net::DrainableIOBuffer> buffer(
       new net::DrainableIOBuffer(new net::IOBuffer(size), size));
   source->Read(0, buffer->BytesRemaining(),
-               reinterpret_cast<uint8*>(buffer->data()),
+               reinterpret_cast<uint8_t*>(buffer->data()),
                base::Bind(&FinishGetImageBytes, buffer,
                           base::Unretained(source), callback));
 }
 
 class ExifFunctions {
  public:
   ExifFunctions() : exif_loader_write_func_(NULL),
                     exif_loader_new_func_(NULL),
                     exif_loader_unref_func_(NULL),
                     exif_loader_get_data_func_(NULL),
@@ skipping 370 matching lines @@
                               &iso_equivalent_);
 
   g_exif_lib.Get().ExifDataFree(data);
 
   extracted_ = true;
 
   callback.Run(true);
 }
 
 }  // namespace metadata