ash: Add a bluetooth entry in the uber tray.

ash/shell.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/shell.h"
 
 #include <algorithm>
 
 #include "ash/app_list/app_list.h"
 #include "ash/ash_switches.h"
 #include "ash/desktop_background/desktop_background_controller.h"
 #include "ash/desktop_background/desktop_background_resources.h"
 #include "ash/desktop_background/desktop_background_view.h"
 #include "ash/drag_drop/drag_drop_controller.h"
 #include "ash/focus_cycler.h"
 #include "ash/ime/input_method_event_filter.h"
 #include "ash/launcher/launcher.h"
 #include "ash/screen_ash.h"
 #include "ash/shell_delegate.h"
 #include "ash/shell_factory.h"
 #include "ash/shell_window_ids.h"
 #include "ash/system/audio/tray_volume.h"
+#include "ash/system/bluetooth/tray_bluetooth.h"
 #include "ash/system/brightness/tray_brightness.h"
 #include "ash/system/ime/tray_ime.h"
 #include "ash/system/network/tray_network.h"
 #include "ash/system/power/power_status_observer.h"
 #include "ash/system/power/power_supply_status.h"
 #include "ash/system/power/tray_power_date.h"
 #include "ash/system/settings/tray_settings.h"
 #include "ash/system/tray/system_tray_delegate.h"
 #include "ash/system/tray/system_tray.h"
 #include "ash/system/tray/tray_empty.h"
@@ skipping 191 matching lines @@
                   "OverlayContainer",
                   lock_screen_related_containers);
 }
 
 class DummySystemTrayDelegate : public SystemTrayDelegate {
  public:
   DummySystemTrayDelegate()
       : muted_(false),
         wifi_enabled_(true),
         cellular_enabled_(true),
+        bluetooth_enabled_(true),
         volume_(0.5) {
   }
 
   virtual ~DummySystemTrayDelegate() {}
 
  private:
 
   // Overridden from SystemTrayDelegate:
   virtual const std::string GetUserDisplayName() const OVERRIDE {
     return "Über tray Über tray Über tray Über tray";
@@ skipping 29 matching lines @@
 
   virtual void ShowSettings() OVERRIDE {
   }
 
   virtual void ShowDateSettings() OVERRIDE {
   }
 
   virtual void ShowNetworkSettings() OVERRIDE {
   }
 
+  virtual void ShowBluetoothSettings() OVERRIDE {
+  }
+
   virtual void ShowHelp() OVERRIDE {
   }
 
   virtual bool IsAudioMuted() const OVERRIDE {
     return muted_;
   }
 
   virtual void SetAudioMuted(bool muted) OVERRIDE {
     muted_ = muted;
   }
@@ skipping 15 matching lines @@
   }
 
   virtual void ShutDown() OVERRIDE {}
 
   virtual void SignOut() OVERRIDE {
     MessageLoop::current()->Quit();
   }
 
   virtual void RequestLockScreen() OVERRIDE {}
 
+  virtual BluetoothDeviceList GetAvailableBluetoothDevices() OVERRIDE {

[Ben Goodger (Google), 2012/03/21 15:52:14]

what is this?

[sadrul, 2012/03/21 16:16:42]

It would return the list of 'available' (currently connected, or previously
connected and remembered, as I understand it) bluetooth devices.

+    return BluetoothDeviceList();
+  }
+
   virtual IMEInfoList GetAvailableIMEList() {
     return IMEInfoList();
   }
 
   virtual NetworkIconInfo GetMostRelevantNetworkIcon(bool large) OVERRIDE {
     return NetworkIconInfo();
   }
 
   virtual void GetAvailableNetworks(
       std::vector<NetworkIconInfo>* list) OVERRIDE {
   }
 
   virtual void ConnectToNetwork(const std::string& network_id) OVERRIDE {
   }
 
+  virtual void AddBluetoothDevice() OVERRIDE {
+  }
+
   virtual void ToggleAirplaneMode() OVERRIDE {
   }
 
   virtual void ToggleWifi() OVERRIDE {
     wifi_enabled_ = !wifi_enabled_;
     ash::NetworkObserver* observer =
         ash::Shell::GetInstance()->tray()->network_observer();
     if (observer) {
       ash::NetworkIconInfo info;
       observer->OnNetworkRefresh(info);
     }
   }
 
   virtual void ToggleCellular() OVERRIDE {
     cellular_enabled_ = !cellular_enabled_;
     ash::NetworkObserver* observer =
         ash::Shell::GetInstance()->tray()->network_observer();
     if (observer) {
       ash::NetworkIconInfo info;
       observer->OnNetworkRefresh(info);
     }
   }
 
+  virtual void ToggleBluetooth() OVERRIDE {
+    bluetooth_enabled_ = !bluetooth_enabled_;
+    ash::BluetoothObserver* observer =
+        ash::Shell::GetInstance()->tray()->bluetooth_observer();
+    if (observer)
+      observer->OnBluetoothRefresh();
+  }
+
   virtual bool GetWifiAvailable() OVERRIDE {
     return true;
   }
 
   virtual bool GetCellularAvailable() OVERRIDE {
     return true;
   }
 
+  virtual bool GetBluetoothAvailable() OVERRIDE {
+    return true;
+  }
+
   virtual bool GetWifiEnabled() OVERRIDE {
     return wifi_enabled_;
   }
 
   virtual bool GetCellularEnabled() OVERRIDE {
     return cellular_enabled_;
   }
 
+  virtual bool GetBluetoothEnabled() OVERRIDE {
+    return bluetooth_enabled_;
+  }
+
   virtual void ChangeProxySettings() OVERRIDE {
   }
 
   bool muted_;
   bool wifi_enabled_;
   bool cellular_enabled_;
+  bool bluetooth_enabled_;
   float volume_;
   SkBitmap null_image_;
 
   DISALLOW_COPY_AND_ASSIGN(DummySystemTrayDelegate);
 };
 
 }  // namespace
 
 // static
 Shell* Shell::instance_ = NULL;
@@ skipping 171 matching lines @@
       status_widget_->GetContentsView()->RemoveAllChildViews(false);
       status_widget_->GetContentsView()->AddChildView(tray_.get());
     }
 
     if (delegate_.get())
       tray_delegate_.reset(delegate_->CreateSystemTrayDelegate(tray_.get()));
     if (!tray_delegate_.get())
       tray_delegate_.reset(new DummySystemTrayDelegate());
 
     internal::TrayVolume* tray_volume = new internal::TrayVolume();
+    internal::TrayBluetooth* tray_bluetooth = new internal::TrayBluetooth();
     internal::TrayBrightness* tray_brightness = new internal::TrayBrightness();
     internal::TrayPowerDate* tray_power_date = new internal::TrayPowerDate();
     internal::TrayNetwork* tray_network = new internal::TrayNetwork;
     internal::TrayUser* tray_user = new internal::TrayUser;
     internal::TrayAccessibility* tray_accessibility =
         new internal::TrayAccessibility;
     internal::TrayCapsLock* tray_caps_lock = new internal::TrayCapsLock;
     internal::TrayIME* tray_ime = new internal::TrayIME;
 
     tray_->accessibility_observer_ = tray_accessibility;
     tray_->audio_observer_ = tray_volume;
+    tray_->bluetooth_observer_ = tray_bluetooth;
     tray_->brightness_observer_ = tray_brightness;
     tray_->caps_lock_observer_ = tray_caps_lock;
     tray_->clock_observer_ = tray_power_date;
     tray_->ime_observer_ = tray_ime;
     tray_->network_observer_ = tray_network;
     tray_->power_status_observer_ = tray_power_date;
     tray_->update_observer_ = tray_user;
     tray_->user_observer_ = tray_user;
 
     tray_->AddTrayItem(tray_user);
     tray_->AddTrayItem(new internal::TrayEmpty());
     tray_->AddTrayItem(tray_power_date);
     tray_->AddTrayItem(tray_network);
+    tray_->AddTrayItem(tray_bluetooth);
     tray_->AddTrayItem(tray_ime);
     tray_->AddTrayItem(tray_volume);
     tray_->AddTrayItem(tray_brightness);
     tray_->AddTrayItem(new internal::TraySettings());
     tray_->AddTrayItem(tray_accessibility);
     tray_->AddTrayItem(tray_caps_lock);
   }
   if (!status_widget_)
     status_widget_ = internal::CreateStatusArea(tray_.get());
 
@@ skipping 161 matching lines @@
   // Create the desktop background image.
   desktop_background_controller_->SetDefaultDesktopBackgroundImage();
 }
 
 void Shell::DisableWorkspaceGridLayout() {
   if (workspace_controller_.get())
     workspace_controller_->workspace_manager()->set_grid_size(0);
 }
 
 }  // namespace ash