Remove kuint64max.

components/storage_monitor/storage_monitor_linux.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.
 
 // StorageMonitorLinux implementation.
 
 #include "components/storage_monitor/storage_monitor_linux.h"
 
 #include <mntent.h>
+#include <stdint.h>
 #include <stdio.h>
 
+#include <limits>
 #include <list>
 
-#include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/metrics/histogram.h"
 #include "base/process/kill.h"
 #include "base/process/launch.h"
 #include "base/process/process.h"
 #include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "components/storage_monitor/media_storage_util.h"
@@ skipping 65 matching lines @@
   }
 
  private:
   bool result_;
 
   DISALLOW_COPY_AND_ASSIGN(ScopedGetDeviceInfoResultRecorder);
 };
 
 // Returns the storage partition size of the device specified by |device_path|.
 // If the requested information is unavailable, returns 0.
-uint64 GetDeviceStorageSize(const base::FilePath& device_path,
-                            struct udev_device* device) {
+uint64_t GetDeviceStorageSize(const base::FilePath& device_path,
+                              struct udev_device* device) {
   // sysfs provides the device size in units of 512-byte blocks.
   const std::string partition_size =
       device::UdevDeviceGetSysattrValue(device, kSizeSysAttr);
 
   // Keep track of device size, to see how often this information is
   // unavailable.
   UMA_HISTOGRAM_BOOLEAN(
       "RemovableDeviceNotificationsLinux.device_partition_size_available",
       !partition_size.empty());
 
-  uint64 total_size_in_bytes = 0;
+  uint64_t total_size_in_bytes = 0;
   if (!base::StringToUint64(partition_size, &total_size_in_bytes))
     return 0;
-  return (total_size_in_bytes <= kuint64max / 512) ?
-      total_size_in_bytes * 512 : 0;
+  return (total_size_in_bytes <= std::numeric_limits<uint64_t>::max() / 512)
+             ? total_size_in_bytes * 512
+             : 0;
 }
 
 // Gets the device information using udev library.
 scoped_ptr<StorageInfo> GetDeviceInfo(const base::FilePath& device_path,
                                       const base::FilePath& mount_point) {
   DCHECK_CURRENTLY_ON(BrowserThread::FILE);
   DCHECK(!device_path.empty());
 
   scoped_ptr<StorageInfo> storage_info;
 
@@ skipping 373 matching lines @@
   mount_priority_map_[mount_device][mount_point] = removable;
   receiver()->ProcessAttach(*storage_info);
 }
 
 StorageMonitor* StorageMonitor::CreateInternal() {
   const base::FilePath kDefaultMtabPath("/etc/mtab");
   return new StorageMonitorLinux(kDefaultMtabPath);
 }
 
 }  // namespace storage_monitor