clang-format all of //ash

ash/system/chromeos/bluetooth/bluetooth_notification_controller.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 "ash/system/chromeos/bluetooth/bluetooth_notification_controller.h"
 
 #include <memory>
 #include <utility>
 
 #include "ash/common/system/system_notifier.h"
@@ skipping 47 matching lines @@
 
  protected:
   ~BluetoothPairingNotificationDelegate() override;
 
   // message_center::NotificationDelegate overrides.
   void Close(bool by_user) override;
   void ButtonClick(int button_index) override;
 
  private:
   // Buttons that appear in notifications.
-  enum Button {
-    BUTTON_ACCEPT,
-    BUTTON_REJECT
-  };
+  enum Button { BUTTON_ACCEPT, BUTTON_REJECT };
 
   // Reference to the underlying Bluetooth Adapter, holding onto this
   // reference ensures the adapter object doesn't go out of scope while we have
   // a pending request and user interaction.
   scoped_refptr<BluetoothAdapter> adapter_;
 
   // Address of the device being paired.
   const std::string address_;
 
   DISALLOW_COPY_AND_ASSIGN(BluetoothPairingNotificationDelegate);
 };
 
 BluetoothPairingNotificationDelegate::BluetoothPairingNotificationDelegate(
     scoped_refptr<BluetoothAdapter> adapter,
     const std::string& address)
-    : adapter_(adapter),
-      address_(address) {
-}
+    : adapter_(adapter), address_(address) {}
 
-BluetoothPairingNotificationDelegate::~BluetoothPairingNotificationDelegate() {
-}
+BluetoothPairingNotificationDelegate::~BluetoothPairingNotificationDelegate() {}
 
 void BluetoothPairingNotificationDelegate::Close(bool by_user) {
   VLOG(1) << "Pairing notification closed. by_user = " << by_user;
   // Ignore notification closes generated as a result of pairing completion.
   if (!by_user)
     return;
 
   // Cancel the pairing of the device, if the object still exists.
   BluetoothDevice* device = adapter_->GetDevice(address_);
   if (device)
@@ skipping 16 matching lines @@
     }
   }
 
   // In any case, remove this pairing notification.
   message_center::MessageCenter::Get()->RemoveNotification(
       kBluetoothDevicePairingNotificationId, false /* by_user */);
 }
 
 }  // namespace
 
-
 namespace ash {
 
 BluetoothNotificationController::BluetoothNotificationController()
     : weak_ptr_factory_(this) {
   BluetoothAdapterFactory::GetAdapter(
       base::Bind(&BluetoothNotificationController::OnGetAdapter,
                  weak_ptr_factory_.GetWeakPtr()));
 }
 
 BluetoothNotificationController::~BluetoothNotificationController() {
   if (adapter_.get()) {
     adapter_->RemoveObserver(this);
     adapter_->RemovePairingDelegate(this);
     adapter_ = NULL;
   }
 }
 
-
 void BluetoothNotificationController::AdapterDiscoverableChanged(
     BluetoothAdapter* adapter,
     bool discoverable) {
   if (discoverable) {
     NotifyAdapterDiscoverable();
   } else {
     // Clear any previous discoverable notification.
     message_center::MessageCenter::Get()->RemoveNotification(
         kBluetoothDeviceDiscoverableNotificationId, false /* by_user */);
   }
@@ skipping 20 matching lines @@
     paired_devices_.insert(device->GetAddress());
     NotifyPairedDevice(device);
   }
 }
 
 void BluetoothNotificationController::DeviceRemoved(BluetoothAdapter* adapter,
                                                     BluetoothDevice* device) {
   paired_devices_.erase(device->GetAddress());
 }
 
-
 void BluetoothNotificationController::RequestPinCode(BluetoothDevice* device) {
   // Cannot provide keyboard entry in a notification; these devices (old car
   // audio systems for the most part) will need pairing to be initiated from
   // the Chromebook.
   device->CancelPairing();
 }
 
 void BluetoothNotificationController::RequestPasskey(BluetoothDevice* device) {
   // Cannot provide keyboard entry in a notification; fortunately the spec
   // doesn't allow for this to be an option when we're receiving the pairing
@@ skipping 38 matching lines @@
 
 void BluetoothNotificationController::AuthorizePairing(
     BluetoothDevice* device) {
   base::string16 message = l10n_util::GetStringFUTF16(
       IDS_ASH_STATUS_TRAY_BLUETOOTH_AUTHORIZE_PAIRING,
       device->GetNameForDisplay());
 
   NotifyPairing(device, message, true);
 }
 
-
 void BluetoothNotificationController::OnGetAdapter(
     scoped_refptr<BluetoothAdapter> adapter) {
   DCHECK(!adapter_.get());
   adapter_ = adapter;
   adapter_->AddObserver(this);
   adapter_->AddPairingDelegate(this,
                                BluetoothAdapter::PAIRING_DELEGATE_PRIORITY_LOW);
 
   // Notify a user if the adapter is already in the discoverable state.
   if (adapter_->IsDiscoverable())
     NotifyAdapterDiscoverable();
 
   // Build a list of the currently paired devices; these don't receive
   // notifications since it's assumed they were previously notified.
   BluetoothAdapter::DeviceList devices = adapter_->GetDevices();
   for (BluetoothAdapter::DeviceList::const_iterator iter = devices.begin();
        iter != devices.end(); ++iter) {
     const BluetoothDevice* device = *iter;
     if (device->IsPaired())
       paired_devices_.insert(device->GetAddress());
   }
 }
 
-
 void BluetoothNotificationController::NotifyAdapterDiscoverable() {
   message_center::RichNotificationData optional;
 
   ui::ResourceBundle& bundle = ui::ResourceBundle::GetSharedInstance();
 
   std::unique_ptr<Notification> notification(new Notification(
       message_center::NOTIFICATION_TYPE_SIMPLE,
       kBluetoothDeviceDiscoverableNotificationId, base::string16() /* title */,
       l10n_util::GetStringFUTF16(IDS_ASH_STATUS_TRAY_BLUETOOTH_DISCOVERABLE,
                                  base::UTF8ToUTF16(adapter_->GetName()),
                                  base::UTF8ToUTF16(adapter_->GetAddress())),
       bundle.GetImageNamed(IDR_AURA_NOTIFICATION_BLUETOOTH),
       base::string16() /* display source */, GURL(),
       message_center::NotifierId(message_center::NotifierId::SYSTEM_COMPONENT,
                                  system_notifier::kNotifierBluetooth),
       optional, NULL));
   message_center::MessageCenter::Get()->AddNotification(
       std::move(notification));
 }
 
 void BluetoothNotificationController::NotifyPairing(
     BluetoothDevice* device,
     const base::string16& message,
     bool with_buttons) {
   message_center::RichNotificationData optional;
   if (with_buttons) {
     optional.buttons.push_back(message_center::ButtonInfo(
-        l10n_util::GetStringUTF16(
-            IDS_ASH_STATUS_TRAY_BLUETOOTH_ACCEPT)));
+        l10n_util::GetStringUTF16(IDS_ASH_STATUS_TRAY_BLUETOOTH_ACCEPT)));
     optional.buttons.push_back(message_center::ButtonInfo(
-        l10n_util::GetStringUTF16(
-            IDS_ASH_STATUS_TRAY_BLUETOOTH_REJECT)));
+        l10n_util::GetStringUTF16(IDS_ASH_STATUS_TRAY_BLUETOOTH_REJECT)));
   }
 
   ui::ResourceBundle& bundle = ui::ResourceBundle::GetSharedInstance();
 
   std::unique_ptr<Notification> notification(new Notification(
       message_center::NOTIFICATION_TYPE_SIMPLE,
       kBluetoothDevicePairingNotificationId, base::string16() /* title */,
       message, bundle.GetImageNamed(IDR_AURA_NOTIFICATION_BLUETOOTH),
       base::string16() /* display source */, GURL(),
       message_center::NotifierId(message_center::NotifierId::SYSTEM_COMPONENT,
@@ skipping 24 matching lines @@
       bundle.GetImageNamed(IDR_AURA_NOTIFICATION_BLUETOOTH),
       base::string16() /* display source */, GURL(),
       message_center::NotifierId(message_center::NotifierId::SYSTEM_COMPONENT,
                                  system_notifier::kNotifierBluetooth),
       optional, NULL));
   message_center::MessageCenter::Get()->AddNotification(
       std::move(notification));
 }
 
 }  // namespace ash