Introduce 'connecting' field to bluetooth device info for system tray

ash/system/bluetooth/tray_bluetooth.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 "ash/system/bluetooth/tray_bluetooth.h"
 
 #include "ash/shell.h"
 #include "ash/system/tray/fixed_sized_scroll_view.h"
 #include "ash/system/tray/hover_highlight_view.h"
 #include "ash/system/tray/system_tray.h"
@@ skipping 110 matching lines @@
         ash::Shell::GetInstance()->system_tray_delegate();
     if (delegate && bluetooth_discovering_) {
       bluetooth_discovering_ = false;
       delegate->BluetoothStopDiscovering();
       throbber_->Stop();
     }
   }
 
   void UpdateBlueToothDeviceList() {
     connected_devices_.clear();
+    connecting_devices_.clear();
     paired_not_connected_devices_.clear();
     discovered_not_paired_devices_.clear();
     BluetoothDeviceList list;
     Shell::GetInstance()->system_tray_delegate()->
         GetAvailableBluetoothDevices(&list);
     for (size_t i = 0; i < list.size(); ++i) {
-      if (list[i].connected)
+      if (list[i].connecting) {
+        list[i].display_name = l10n_util::GetStringFUTF16(
+            IDS_ASH_STATUS_TRAY_BLUETOOTH_CONNECTING, list[i].display_name);
+        connecting_devices_.push_back(list[i]);
+      } else if (list[i].connected) {
         connected_devices_.push_back(list[i]);
-      else if (list[i].paired)
+      } else if (list[i].paired) {
         paired_not_connected_devices_.push_back(list[i]);
-      else
+      } else {
         discovered_not_paired_devices_.push_back(list[i]);
+      }
     }
   }
 
   void AppendHeaderEntry() {
     CreateSpecialRow(IDS_ASH_STATUS_TRAY_BLUETOOTH, this);
 
     if (login_ == user::LOGGED_IN_LOCKED)
       return;
 
     throbber_ = new ThrobberView;
@@ skipping 39 matching lines @@
         toggle_bluetooth_) {
       enable_bluetooth_ =
           AddScrollListItem(
               l10n_util::GetStringUTF16(IDS_ASH_STATUS_TRAY_ENABLE_BLUETOOTH),
               gfx::Font::NORMAL, false, true);
     }
 
     AppendSameTypeDevicesToScrollList(
         connected_devices_, true, true, bluetooth_enabled);
     AppendSameTypeDevicesToScrollList(
+        connecting_devices_, true, false, bluetooth_enabled);
+    AppendSameTypeDevicesToScrollList(
         paired_not_connected_devices_, false, false, bluetooth_enabled);
     if (discovered_not_paired_devices_.size() > 0)
       AddScrollSeparator();
     AppendSameTypeDevicesToScrollList(
         discovered_not_paired_devices_, false, false, bluetooth_enabled);
 
     // Show user Bluetooth state if there is no bluetooth devices in list.
     if (device_map_.size() == 0) {
       if (blueooth_available && bluetooth_enabled) {
         AddScrollListItem(
             l10n_util::GetStringUTF16(
                 IDS_ASH_STATUS_TRAY_BLUETOOTH_DISCOVERING),
             gfx::Font::NORMAL, false, true);
       }
     }
 
     scroll_content()->SizeToPreferredSize();
     static_cast<views::View*>(scroller())->Layout();
   }
 
   void AppendSameTypeDevicesToScrollList(const BluetoothDeviceList& list,
                                          bool bold,
                                          bool checked,
                                          bool enabled) {
     for (size_t i = 0; i < list.size(); ++i) {
+      string16 display_name = list[i].display_name;

[jennyz, 2013/04/15 18:47:17]

nit, you don't need to use this variable display_name, since it is only used
once.

[Jun Mukai, 2013/04/15 21:09:45]

Done.

       HoverHighlightView* container = AddScrollListItem(
-          list[i].display_name,
+          display_name,
           bold? gfx::Font::BOLD : gfx::Font::NORMAL,
           checked, enabled);
       device_map_[container] = list[i].address;
     }
   }
 
   HoverHighlightView* AddScrollListItem(const base::string16& text,
                                         gfx::Font::FontStyle style,
                                         bool checked,
                                         bool enabled) {
@@ skipping 18 matching lines @@
     HoverHighlightView* container = new HoverHighlightView(this);
     container->AddLabel(
         rb.GetLocalizedString(IDS_ASH_STATUS_TRAY_BLUETOOTH_ADD_DEVICE),
         gfx::Font::NORMAL);
     container->SetEnabled(delegate->GetBluetoothAvailable());
     AddChildView(container);
     add_device_ = container;
   }
 
   // Returns true if the device with |device_id| is found in |device_list|,
-  // and the display_name of the device will be returned in |display_name|.
+  // and the display_name of the device will be returned in |display_name| if
+  // it's not NULL.
   bool FoundDevice(const std::string& device_id,
                    const BluetoothDeviceList& device_list,
                    base::string16* display_name) {
     for (size_t i = 0; i < device_list.size(); ++i) {
       if (device_list[i].address == device_id) {
-        *display_name = device_list[i].display_name;
+        if (display_name)
+          *display_name = device_list[i].display_name;
         return true;
       }
     }
     return false;
   }
 
   // Updates UI of the clicked bluetooth device to show it is being connected
   // or disconnected if such an operation is going to be performed underway.
   void UpdateClickedDevice(std::string device_id, views::View* item_container) {
     base::string16 display_name;
@@ skipping 24 matching lines @@
       if (!delegate->GetBluetoothEnabled())
         delegate->ToggleBluetooth();
       delegate->AddBluetoothDevice();
     } else if (sender == enable_bluetooth_) {
       delegate->ToggleBluetooth();
     } else {
       if (!delegate->GetBluetoothEnabled())
         return;
       std::map<views::View*, std::string>::iterator find;
       find = device_map_.find(sender);
-      if (find != device_map_.end()) {
-        std::string device_id = find->second;
-        UpdateClickedDevice(device_id, sender);
-        delegate->ToggleBluetoothConnection(device_id);
-      }
+      if (find == device_map_.end())
+        return;
+      std::string device_id = find->second;
+      if (FoundDevice(device_id, connecting_devices_, NULL))
+        return;
+      UpdateClickedDevice(device_id, sender);
+      delegate->ToggleBluetoothConnection(device_id);
     }
   }
 
   // Overridden from ButtonListener.
   virtual void ButtonPressed(views::Button* sender,
                              const ui::Event& event) OVERRIDE {
     ash::SystemTrayDelegate* delegate =
         ash::Shell::GetInstance()->system_tray_delegate();
     if (sender == toggle_bluetooth_)
       delegate->ToggleBluetooth();
     else
       NOTREACHED();
   }
 
   user::LoginStatus login_;
 
   std::map<views::View*, std::string> device_map_;
   views::View* add_device_;
   ThrobberView* throbber_;
   TrayPopupHeaderButton* toggle_bluetooth_;
   HoverHighlightView* enable_bluetooth_;
   BluetoothDeviceList connected_devices_;
+  BluetoothDeviceList connecting_devices_;
   BluetoothDeviceList paired_not_connected_devices_;
   BluetoothDeviceList discovered_not_paired_devices_;
   bool bluetooth_discovering_;
 
   DISALLOW_COPY_AND_ASSIGN(BluetoothDetailedView);
 };
 
 }  // namespace tray
 
 TrayBluetooth::TrayBluetooth(SystemTray* system_tray)
@@ skipping 48 matching lines @@
 }
 
 void TrayBluetooth::OnBluetoothDiscoveringChanged() {
   if (!detailed_)
     return;
   detailed_->Update();
 }
 
 }  // namespace internal
 }  // namespace ash