Switch to standard integer types in components/, part 4 of 4.

components/storage_monitor/storage_monitor_chromeos_unittest.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 "components/storage_monitor/storage_monitor_chromeos.h"
 
+#include <stdint.h>
+
 #include "base/files/file_util.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/logging.h"
+#include "base/macros.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/run_loop.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chromeos/disks/mock_disk_mount_manager.h"
 #include "components/storage_monitor/mock_removable_storage_observer.h"
 #include "components/storage_monitor/removable_device_constants.h"
 #include "components/storage_monitor/storage_info.h"
 #include "components/storage_monitor/test_media_transfer_protocol_manager_linux.h"
 #include "components/storage_monitor/test_storage_monitor.h"
 #include "content/public/browser/browser_thread.h"
@@ skipping 17 matching lines @@
 const char kMountPointB[] = "mnt_b";
 const char kSDCardDeviceName1[] = "8.6 MB Amy_SD";
 const char kSDCardDeviceName2[] = "8.6 MB SD Card";
 const char kSDCardMountPoint1[] = "media/removable/Amy_SD";
 const char kSDCardMountPoint2[] = "media/removable/SD Card";
 const char kProductName[] = "Z101";
 const char kUniqueId1[] = "FFFF-FFFF";
 const char kUniqueId2[] = "FFFF-FF0F";
 const char kVendorName[] = "CompanyA";
 
-uint64 kDevice1SizeInBytes = 113048;
-uint64 kDevice2SizeInBytes = 212312;
-uint64 kSDCardSizeInBytes = 9000000;
+uint64_t kDevice1SizeInBytes = 113048;
+uint64_t kDevice2SizeInBytes = 212312;
+uint64_t kSDCardSizeInBytes = 9000000;
 
 std::string GetDCIMDeviceId(const std::string& unique_id) {
   return StorageInfo::MakeDeviceId(
       StorageInfo::REMOVABLE_MASS_STORAGE_WITH_DCIM,
       kFSUniqueIdPrefix + unique_id);
 }
 
 // A test version of StorageMonitorCros that exposes protected methods to tests.
 class TestStorageMonitorCros : public StorageMonitorCros {
  public:
@@ skipping 40 matching lines @@
   void SetUp() override;
   void TearDown() override;
 
   void MountDevice(chromeos::MountError error_code,
                    const DiskMountManager::MountPointInfo& mount_info,
                    const std::string& unique_id,
                    const std::string& device_label,
                    const std::string& vendor_name,
                    const std::string& product_name,
                    chromeos::DeviceType device_type,
-                   uint64 device_size_in_bytes);
+                   uint64_t device_size_in_bytes);
 
   void UnmountDevice(chromeos::MountError error_code,
                      const DiskMountManager::MountPointInfo& mount_info);
 
-  uint64 GetDeviceStorageSize(const std::string& device_location);
+  uint64_t GetDeviceStorageSize(const std::string& device_location);
 
   // Create a directory named |dir| relative to the test directory.
   // Set |with_dcim_dir| to true if the created directory will have a "DCIM"
   // subdirectory.
   // Returns the full path to the created directory on success, or an empty
   // path on failure.
   base::FilePath CreateMountPoint(const std::string& dir, bool with_dcim_dir);
 
   static void PostQuitToUIThread();
   static void WaitForFileThread();
@@ skipping 60 matching lines @@
 }
 
 void StorageMonitorCrosTest::MountDevice(
     chromeos::MountError error_code,
     const DiskMountManager::MountPointInfo& mount_info,
     const std::string& unique_id,
     const std::string& device_label,
     const std::string& vendor_name,
     const std::string& product_name,
     chromeos::DeviceType device_type,
-    uint64 device_size_in_bytes) {
+    uint64_t device_size_in_bytes) {
   if (error_code == chromeos::MOUNT_ERROR_NONE) {
     disk_mount_manager_mock_->CreateDiskEntryForMountDevice(
         mount_info,
         unique_id,
         device_label,
         vendor_name,
         product_name,
         device_type,
         device_size_in_bytes,
         false /* is_parent */,
         true /* has_media */,
         false /* on_boot_device */,
         true /* on_removable_device */);
   }
   monitor_->OnMountEvent(DiskMountManager::MOUNTING, error_code, mount_info);
   WaitForFileThread();
 }
 
 void StorageMonitorCrosTest::UnmountDevice(
     chromeos::MountError error_code,
     const DiskMountManager::MountPointInfo& mount_info) {
   monitor_->OnMountEvent(DiskMountManager::UNMOUNTING, error_code, mount_info);
   if (error_code == chromeos::MOUNT_ERROR_NONE)
     disk_mount_manager_mock_->RemoveDiskEntryForMountDevice(mount_info);
   WaitForFileThread();
 }
 
-uint64 StorageMonitorCrosTest::GetDeviceStorageSize(
+uint64_t StorageMonitorCrosTest::GetDeviceStorageSize(
     const std::string& device_location) {
   StorageInfo info;
   if (!monitor_->GetStorageInfoForPath(base::FilePath(device_location), &info))
     return 0;
 
   return info.total_size_in_bytes();
 }
 
 base::FilePath StorageMonitorCrosTest::CreateMountPoint(
     const std::string& dir, bool with_dcim_dir) {
@@ skipping 310 matching lines @@
                         base::Bind(&StorageMonitorCrosTest::EjectNotify,
                                    base::Unretained(this)));
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(StorageMonitor::EJECT_OK, status_);
 }
 
 }  // namespace
 
 }  // namespace storage_monitor