Switch to standard integer types in chromeos/.

chromeos/dbus/cros_disks_client.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 "chromeos/dbus/cros_disks_client.h"
 
+#include <stddef.h>
+#include <stdint.h>
+
 #include <map>
 
 #include "base/bind.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/location.h"
+#include "base/macros.h"
 #include "base/stl_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/sys_info.h"
 #include "base/task_runner_util.h"
 #include "base/threading/worker_pool.h"
 #include "base/values.h"
 #include "chromeos/dbus/fake_cros_disks_client.h"
 #include "dbus/bus.h"
 #include "dbus/message.h"
 #include "dbus/object_path.h"
@@ skipping 14 matching lines @@
 
 const char* kDefaultUnmountOptions[] = {
   "force",
 };
 
 const char kLazyUnmountOption[] = "lazy";
 
 const char kMountLabelOption[] = "mountlabel";
 
 // Checks if retrieved media type is in boundaries of DeviceMediaType.
-bool IsValidMediaType(uint32 type) {
-  return type < static_cast<uint32>(cros_disks::DEVICE_MEDIA_NUM_VALUES);
+bool IsValidMediaType(uint32_t type) {
+  return type < static_cast<uint32_t>(cros_disks::DEVICE_MEDIA_NUM_VALUES);
 }
 
 // Translates enum used in cros-disks to enum used in Chrome.
 // Note that we could just do static_cast, but this is less sensitive to
 // changes in cros-disks.
-DeviceType DeviceMediaTypeToDeviceType(uint32 media_type_uint32) {
+DeviceType DeviceMediaTypeToDeviceType(uint32_t media_type_uint32) {
   if (!IsValidMediaType(media_type_uint32))
     return DEVICE_TYPE_UNKNOWN;
 
   cros_disks::DeviceMediaType media_type =
       cros_disks::DeviceMediaType(media_type_uint32);
 
   switch (media_type) {
     case(cros_disks::DEVICE_MEDIA_UNKNOWN):
       return DEVICE_TYPE_UNKNOWN;
     case(cros_disks::DEVICE_MEDIA_USB):
       return DEVICE_TYPE_USB;
     case(cros_disks::DEVICE_MEDIA_SD):
       return DEVICE_TYPE_SD;
     case(cros_disks::DEVICE_MEDIA_OPTICAL_DISC):
       return DEVICE_TYPE_OPTICAL_DISC;
     case(cros_disks::DEVICE_MEDIA_MOBILE):
       return DEVICE_TYPE_MOBILE;
     case(cros_disks::DEVICE_MEDIA_DVD):
       return DEVICE_TYPE_DVD;
     default:
       return DEVICE_TYPE_UNKNOWN;
   }
 }
 
 bool ReadMountEntryFromDbus(dbus::MessageReader* reader, MountEntry* entry) {
-  uint32 error_code = 0;
+  uint32_t error_code = 0;
   std::string source_path;
-  uint32 mount_type = 0;
+  uint32_t mount_type = 0;
   std::string mount_path;
   if (!reader->PopUint32(&error_code) ||
       !reader->PopString(&source_path) ||
       !reader->PopUint32(&mount_type) ||
       !reader->PopString(&mount_path)) {
     return false;
   }
   *entry = MountEntry(static_cast<MountError>(error_code), source_path,
                       static_cast<MountType>(mount_type), mount_path);
   return true;
@@ skipping 210 matching lines @@
 
     // Temporarly allow Unmount method to report failure both by setting dbus
     // error (in which case response is not set) and by returning mount error
     // different from MOUNT_ERROR_NONE. This is done so we can change Unmount
     // method to return mount error (http://crbug.com/288974) without breaking
     // Chrome.
     // TODO(tbarzic): When Unmount implementation is changed on cros disks side,
     // make this fail if reader is not able to read the error code value from
     // the response.
     dbus::MessageReader reader(response);
-    uint32 error_code = 0;
+    uint32_t error_code = 0;
     if (reader.PopUint32(&error_code) &&
         static_cast<MountError>(error_code) != MOUNT_ERROR_NONE) {
       error_callback.Run();
       return;
     }
 
     callback.Run();
   }
 
   // Handles the result of EnumerateAutoMountableDevices and calls |callback| or
@@ skipping 95 matching lines @@
     if (!ReadMountEntryFromDbus(&reader, &entry)) {
       LOG(ERROR) << "Invalid signal: " << signal->ToString();
       return;
     }
     handler.Run(entry);
   }
 
   // Handles FormatCompleted signal and calls |handler|.
   void OnFormatCompleted(FormatCompletedHandler handler, dbus::Signal* signal) {
     dbus::MessageReader reader(signal);
-    uint32 error_code = 0;
+    uint32_t error_code = 0;
     std::string device_path;
     if (!reader.PopUint32(&error_code) || !reader.PopString(&device_path)) {
       LOG(ERROR) << "Invalid signal: " << signal->ToString();
       return;
     }
     handler.Run(static_cast<FormatError>(error_code), device_path);
   }
 
   // Handles the result of signal connection setup.
   void OnSignalConnected(const std::string& interface,
@@ skipping 72 matching lines @@
 //   dict entry {
 //     string "DeviceIsReadOnly"
 //     variant       bool false
 //   }
 //   dict entry {
 //     string "DeviceIsVirtual"
 //     variant       bool false
 //   }
 //   dict entry {
 //     string "DeviceMediaType"
-//     variant       uint32 1
+//     variant       uint32_t 1
 //   }
 //   dict entry {
 //     string "DeviceMountPaths"
 //     variant       array [
 //       ]
 //   }
 //   dict entry {
 //     string "DevicePresentationHide"
 //     variant       bool true
 //   }
 //   dict entry {
 //     string "DeviceSize"
-//     variant       uint64 7998537728
+//     variant       uint64_t 7998537728
 //   }
 //   dict entry {
 //     string "DriveIsRotational"
 //     variant       bool false
 //   }
 //   dict entry {
 //     string "VendorId"
 //     variant       string "18d1"
 //   }
 //   dict entry {
@@ skipping 53 matching lines @@
       cros_disks::kVendorName, &vendor_name_);
   properties->GetStringWithoutPathExpansion(
       cros_disks::kProductId, &product_id_);
   properties->GetStringWithoutPathExpansion(
       cros_disks::kProductName, &product_name_);
   properties->GetStringWithoutPathExpansion(
       cros_disks::kDriveModel, &drive_model_);
   properties->GetStringWithoutPathExpansion(cros_disks::kIdLabel, &label_);
   properties->GetStringWithoutPathExpansion(cros_disks::kIdUuid, &uuid_);
 
-  // dbus::PopDataAsValue() pops uint64 as double.
-  // The top 11 bits of uint64 are dropped by the use of double. But, this works
+  // dbus::PopDataAsValue() pops uint64_t as double.
+  // The top 11 bits of uint64_t are dropped by the use of double. But, this
+  // works
   // unless the size exceeds 8 PB.
   double device_size_double = 0;
   if (properties->GetDoubleWithoutPathExpansion(cros_disks::kDeviceSize,
                                                 &device_size_double))
     total_size_in_bytes_ = device_size_double;
 
-  // dbus::PopDataAsValue() pops uint32 as double.
+  // dbus::PopDataAsValue() pops uint32_t as double.
   double media_type_double = 0;
   if (properties->GetDoubleWithoutPathExpansion(cros_disks::kDeviceMediaType,
                                                 &media_type_double))
     device_type_ = DeviceMediaTypeToDeviceType(media_type_double);
 
   base::ListValue* mount_paths = NULL;
   if (properties->GetListWithoutPathExpansion(cros_disks::kDeviceMountPaths,
                                               &mount_paths))
     mount_paths->GetString(0, &mount_path_);
 }
@@ skipping 21 matching lines @@
 }
 
 // static
 base::FilePath CrosDisksClient::GetRemovableDiskMountPoint() {
   return base::FilePath(base::SysInfo::IsRunningOnChromeOS() ?
                         FILE_PATH_LITERAL("/media/removable") :
                         FILE_PATH_LITERAL("/tmp/chromeos/media/removable"));
 }
 
 }  // namespace chromeos