[Clean-up] Run git cl format over the proximity_auth component.

components/proximity_auth/bluetooth_util_chromeos.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/proximity_auth/bluetooth_util.h"
 
 #include <stdint.h>
 #include <sys/socket.h>
 #include <algorithm>
 #include <vector>
@@ skipping 51 matching lines @@
 struct SeekDeviceResult {
   // Whether the connection to the device succeeded.
   bool success;
 
   // If the connection failed, an error message describing the failure.
   std::string error_message;
 };
 
 // Writes |address| into the |result|. Return true on success, false if the
 // |address| is not a valid Bluetooth address.
-bool BluetoothAddressToBdaddr(const std::string& address,
-                              bdaddr_t* result) {
+bool BluetoothAddressToBdaddr(const std::string& address, bdaddr_t* result) {
   std::string canonical_address = BluetoothDevice::CanonicalizeAddress(address);
   if (canonical_address.empty())
     return false;
 
   std::vector<std::string> octets;
   base::SplitString(canonical_address, ':', &octets);
   DCHECK_EQ(octets.size(), 6U);
 
   // BlueZ expects the octets in the reverse order.
   std::reverse(octets.begin(), octets.end());
@@ skipping 27 matching lines @@
   addr.l2_family = AF_BLUETOOTH;
   addr.l2_psm = base::ByteSwapToLE16(SDP_PSM);
   if (!BluetoothAddressToBdaddr(device_address, &addr.l2_bdaddr)) {
     seek_result.error_message = kInvalidDeviceAddress;
     return seek_result;
   }
 
   net::SocketDescriptor socket_descriptor =
       socket(AF_BLUETOOTH, SOCK_SEQPACKET, BTPROTO_L2CAP);
   int result = connect(socket_descriptor,
-                       reinterpret_cast<struct sockaddr *>(&addr),
+                       reinterpret_cast<struct sockaddr*>(&addr),
                        sizeof(addr));
   if (result == 0) {
     seek_result.success = true;
     task_runner->PostDelayedTask(
         FROM_HERE,
         base::Bind(&CloseSocket, socket_descriptor),
         base::TimeDelta::FromSeconds(kCloseSDPConnectionDelaySec));
   } else {
     // TODO(isherman): Pass a better message based on the errno?
     seek_result.error_message = kUnableToConnectToDevice;
@@ skipping 12 matching lines @@
 
 }  // namespace
 
 void SeekDeviceByAddress(const std::string& device_address,
                          const base::Closure& callback,
                          const ErrorCallback& error_callback,
                          base::TaskRunner* task_runner) {
   base::PostTaskAndReplyWithResult(
       task_runner,
       FROM_HERE,
-      base::Bind(&SeekDeviceByAddressImpl, device_address,
+      base::Bind(&SeekDeviceByAddressImpl,
+                 device_address,
                  make_scoped_refptr(task_runner)),
       base::Bind(&OnSeekDeviceResult, callback, error_callback));
 }
 
 void ConnectToServiceInsecurely(
     device::BluetoothDevice* device,
     const device::BluetoothUUID& uuid,
     const BluetoothDevice::ConnectToServiceCallback& callback,
     const BluetoothDevice::ConnectToServiceErrorCallback& error_callback) {
   static_cast<chromeos::BluetoothDeviceChromeOS*>(device)
       ->ConnectToServiceInsecurely(uuid, callback, error_callback);
 }
 
 }  // namespace bluetooth_util
 }  // namespace proximity_auth