Remove kint64max.

chrome/browser/media_galleries/win/mtp_device_operations_util.cc

 // Copyright (c) 2013 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/browser/media_galleries/win/mtp_device_operations_util.h"
 
 #include <portabledevice.h>
+#include <stdint.h>
 
 #include <algorithm>
+#include <limits>
 
-#include "base/basictypes.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/logging.h"
 #include "base/numerics/safe_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/threading/thread_restrictions.h"
 #include "base/time/time.h"
 #include "base/win/scoped_co_mem.h"
 #include "base/win/scoped_propvariant.h"
 #include "chrome/common/chrome_constants.h"
@@ skipping 121 matching lines @@
   FILETIME file_time;
   if (last_modified_date.get().vt == VT_DATE &&
       VariantTimeToSystemTime(last_modified_date.get().date, &system_time) &&
       SystemTimeToFileTime(&system_time, &file_time)) {
     *last_modified_time = base::Time::FromFileTime(file_time);
   }
 }
 
 // Gets the size of the file object in bytes from the property key values
 // specified by the |properties_values|. On failure, return -1.
-int64 GetObjectSize(IPortableDeviceValues* properties_values) {
+int64_t GetObjectSize(IPortableDeviceValues* properties_values) {
   DCHECK(properties_values);
   ULONGLONG actual_size;
   HRESULT hr = properties_values->GetUnsignedLargeIntegerValue(WPD_OBJECT_SIZE,
                                                                &actual_size);
-  bool success = SUCCEEDED(hr) && (actual_size <= kint64max);
-  return success ? static_cast<int64>(actual_size) : -1;
+  bool success = SUCCEEDED(hr) &&
+                 (actual_size <=
+                  static_cast<ULONGLONG>(std::numeric_limits<int64_t>::max()));
+  return success ? static_cast<int64_t>(actual_size) : -1;
 }
 
 // Gets the details of the object specified by the |object_id| given the media
 // transfer protocol |device|. On success, returns true and fills in |name|,
 // |is_directory|, |size|. |last_modified_time| will be filled in if possible,
 // but failure to get it doesn't prevent success.
 bool GetObjectDetails(IPortableDevice* device,
                       const base::string16 object_id,
                       base::string16* name,
                       bool* is_directory,
-                      int64* size,
+                      int64_t* size,
                       base::Time* last_modified_time) {
   base::ThreadRestrictions::AssertIOAllowed();
   DCHECK(device);
   DCHECK(!object_id.empty());
   DCHECK(name);
   DCHECK(is_directory);
   DCHECK(size);
   DCHECK(last_modified_time);
   base::win::ScopedComPtr<IPortableDeviceContent> content =
       GetDeviceContent(device);
@@ skipping 37 matching lines @@
     // Directory entry does not have size and last modified date property key
     // values.
     *size = 0;
     *last_modified_time = base::Time();
     return true;
   }
 
   // Try to get the last modified time, but don't fail if we can't.
   GetLastModifiedTime(properties_values.get(), last_modified_time);
 
-  int64 object_size = GetObjectSize(properties_values.get());
+  int64_t object_size = GetObjectSize(properties_values.get());
   if (object_size < 0)
     return false;
   *size = object_size;
   return true;
 }
 
 // Creates an MTP device object entry for the given |device| and |object_id|.
 // On success, returns true and fills in |entry|.
 MTPDeviceObjectEntry GetMTPDeviceObjectEntry(IPortableDevice* device,
                                              const base::string16& object_id) {
   base::ThreadRestrictions::AssertIOAllowed();
   DCHECK(device);
   DCHECK(!object_id.empty());
   base::string16 name;
   bool is_directory;
-  int64 size;
+  int64_t size;
   base::Time last_modified_time;
   MTPDeviceObjectEntry entry;
   if (GetObjectDetails(device, object_id, &name, &is_directory, &size,
                        &last_modified_time)) {
     entry = MTPDeviceObjectEntry(object_id, name, is_directory, size,
                                  last_modified_time);
   }
   return entry;
 }
 
@@ skipping 150 matching lines @@
       object_entries.empty())
     return base::string16();
   // TODO(thestig): This DCHECK can fail. Multiple MTP objects can have
   // the same name. Handle the situation gracefully. Refer to crbug.com/169930
   // for more details.
   DCHECK_EQ(1U, object_entries.size());
   return object_entries[0].object_id;
 }
 
 }  // namespace media_transfer_protocol