Switch to standard integer types in device/.

device/bluetooth/dbus/bluetooth_gatt_descriptor_service_provider.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 "device/bluetooth/dbus/bluetooth_gatt_descriptor_service_provider.h"
 
+#include <stddef.h>
+
 #include "base/bind.h"
 #include "base/logging.h"
+#include "base/macros.h"
 #include "base/memory/weak_ptr.h"
 #include "base/strings/string_util.h"
 #include "base/threading/platform_thread.h"
 #include "dbus/exported_object.h"
 #include "dbus/message.h"
 #include "device/bluetooth/dbus/bluez_dbus_manager.h"
 #include "device/bluetooth/dbus/fake_bluetooth_gatt_descriptor_service_provider.h"
 #include "third_party/cros_system_api/dbus/service_constants.h"
 
 namespace bluez {
@@ skipping 57 matching lines @@
                    weak_ptr_factory_.GetWeakPtr()));
   }
 
   ~BluetoothGattDescriptorServiceProviderImpl() override {
     VLOG(1) << "Cleaning up Bluetooth GATT characteristic descriptor: "
             << object_path_.value();
     bus_->UnregisterExportedObject(object_path_);
   }
 
   // BluetoothGattDescriptorServiceProvider override.
-  void SendValueChanged(const std::vector<uint8>& value) override {
+  void SendValueChanged(const std::vector<uint8_t>& value) override {
     VLOG(2) << "Emitting a PropertiesChanged signal for descriptor value.";
     dbus::Signal signal(dbus::kDBusPropertiesInterface,
                         dbus::kDBusPropertiesChangedSignal);
     dbus::MessageWriter writer(&signal);
     dbus::MessageWriter array_writer(NULL);
     dbus::MessageWriter dict_entry_writer(NULL);
     dbus::MessageWriter variant_writer(NULL);
 
     // interface_name
     writer.AppendString(
@@ skipping 138 matching lines @@
         error_message = "No such property: '" + property_name + "'.";
       }
       scoped_ptr<dbus::ErrorResponse> error_response =
           dbus::ErrorResponse::FromMethodCall(method_call, error_name,
                                               error_message);
       response_sender.Run(error_response.Pass());
       return;
     }
 
     // Obtain the value.
-    const uint8* bytes = NULL;
+    const uint8_t* bytes = NULL;
     size_t length = 0;
     if (!variant_reader.PopArrayOfBytes(&bytes, &length)) {
       scoped_ptr<dbus::ErrorResponse> error_response =
           dbus::ErrorResponse::FromMethodCall(
               method_call, kErrorInvalidArgs,
               "Property '" + property_name + "' has type 'ay'.");
       response_sender.Run(error_response.Pass());
       return;
     }
 
     // Pass the set request onto the delegate.
-    std::vector<uint8> value(bytes, bytes + length);
+    std::vector<uint8_t> value(bytes, bytes + length);
     DCHECK(delegate_);
     delegate_->SetDescriptorValue(
         value, base::Bind(&BluetoothGattDescriptorServiceProviderImpl::OnSet,
                           weak_ptr_factory_.GetWeakPtr(), method_call,
                           response_sender),
         base::Bind(&BluetoothGattDescriptorServiceProviderImpl::OnFailure,
                    weak_ptr_factory_.GetWeakPtr(), method_call,
                    response_sender));
   }
 
@@ skipping 45 matching lines @@
                   bool success) {
     LOG_IF(WARNING, !success) << "Failed to export " << interface_name << "."
                               << method_name;
   }
 
   // Called by the Delegate in response to a method to call to get all
   // properties, in which the delegate has successfully returned the
   // descriptor value.
   void OnGetAll(dbus::MethodCall* method_call,
                 dbus::ExportedObject::ResponseSender response_sender,
-                const std::vector<uint8>& value) {
+                const std::vector<uint8_t>& value) {
     VLOG(2) << "Descriptor value obtained from delegate. Responding to "
             << "GetAll.";
 
     scoped_ptr<dbus::Response> response =
         dbus::Response::FromMethodCall(method_call);
     dbus::MessageWriter writer(response.get());
     dbus::MessageWriter array_writer(NULL);
     dbus::MessageWriter dict_entry_writer(NULL);
     dbus::MessageWriter variant_writer(NULL);
 
@@ skipping 21 matching lines @@
 
     writer.CloseContainer(&array_writer);
 
     response_sender.Run(response.Pass());
   }
 
   // Called by the Delegate in response to a successful method call to get the
   // descriptor value.
   void OnGet(dbus::MethodCall* method_call,
              dbus::ExportedObject::ResponseSender response_sender,
-             const std::vector<uint8>& value) {
+             const std::vector<uint8_t>& value) {
     VLOG(2) << "Returning descriptor value obtained from delegate.";
     scoped_ptr<dbus::Response> response =
         dbus::Response::FromMethodCall(method_call);
     dbus::MessageWriter writer(response.get());
     dbus::MessageWriter variant_writer(NULL);
 
     writer.OpenVariant("ay", &variant_writer);
     variant_writer.AppendArrayOfBytes(value.data(), value.size());
     writer.CloseContainer(&variant_writer);
 
@@ skipping 72 matching lines @@
     const dbus::ObjectPath& characteristic_path) {
   if (!bluez::BluezDBusManager::Get()->IsUsingStub()) {
     return new BluetoothGattDescriptorServiceProviderImpl(
         bus, object_path, delegate, uuid, permissions, characteristic_path);
   }
   return new FakeBluetoothGattDescriptorServiceProvider(
       object_path, delegate, uuid, permissions, characteristic_path);
 }
 
 }  // namespace bluez