ash/system/tray/test_system_tray_delegate.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "ash/system/tray/test_system_tray_delegate.h"
   6
   7 #include <string>
   8
   9 #include "ash/session_state_delegate.h"
  10 #include "ash/shell.h"
  11 #include "ash/volume_control_delegate.h"
  12 #include "base/utf_string_conversions.h"
  13 #include "base/message_loop.h"
  14 #include "base/string16.h"
  15 #include "base/time.h"
  16
  17 namespace ash {
  18 namespace test {
  19
  20 namespace {
  21
  22 class TestVolumeControlDelegate : public VolumeControlDelegate {
  23  public:
  24   TestVolumeControlDelegate() {}
  25   virtual ~TestVolumeControlDelegate() {}
  26
  27   virtual bool HandleVolumeMute(const ui::Accelerator& accelerator) OVERRIDE {
  28     return true;
  29   }
  30   virtual bool HandleVolumeDown(const ui::Accelerator& accelerator) OVERRIDE {
  31     return true;
  32   }
  33   virtual bool HandleVolumeUp(const ui::Accelerator& accelerator) OVERRIDE {
  34     return true;
  35   }
  36   virtual void SetVolumePercent(double percent) OVERRIDE {
  37   }
  38   virtual bool IsAudioMuted() const OVERRIDE {
  39     return true;
  40   }
  41   virtual void SetAudioMuted(bool muted) OVERRIDE {
  42   }
  43   virtual float GetVolumeLevel() const OVERRIDE {
  44     return 0.0;
  45   }
  46   virtual void SetVolumeLevel(float level) OVERRIDE {
  47   }
  48
  49  private:
  50   DISALLOW_COPY_AND_ASSIGN(TestVolumeControlDelegate);
  51 };
  52
  53 }  // namespace
  54
  55 TestSystemTrayDelegate::TestSystemTrayDelegate()
  56     : wifi_enabled_(true),
  57       cellular_enabled_(true),
  58       bluetooth_enabled_(true),
  59       caps_lock_enabled_(false),
  60       volume_control_delegate_(
  61           ALLOW_THIS_IN_INITIALIZER_LIST(new TestVolumeControlDelegate)) {
  62 }
  63
  64 TestSystemTrayDelegate::~TestSystemTrayDelegate() {
  65 }
  66
  67 void TestSystemTrayDelegate::Initialize() {
  68 }
  69
  70 void TestSystemTrayDelegate::Shutdown() {
  71 }
  72
  73 bool TestSystemTrayDelegate::GetTrayVisibilityOnStartup() {
  74   return true;
  75 }
  76
  77 // Overridden from SystemTrayDelegate:
  78 const base::string16 TestSystemTrayDelegate::GetUserDisplayName() const {
  79   return UTF8ToUTF16("Über tray Über tray Über tray Über tray");
  80 }
  81
  82 const std::string TestSystemTrayDelegate::GetUserEmail() const {
  83   return "über@tray";
  84 }
  85
  86 const gfx::ImageSkia& TestSystemTrayDelegate::GetUserImage() const {
  87   return null_image_;
  88 }
  89
  90 user::LoginStatus TestSystemTrayDelegate::GetUserLoginStatus() const {
  91   // At new user image screen manager->IsUserLoggedIn() would return true
  92   // but there's no browser session available yet so use SessionStarted().
  93   SessionStateDelegate* delegate =
  94       Shell::GetInstance()->session_state_delegate();
  95
  96   if (!delegate->IsActiveUserSessionStarted())
  97     return ash::user::LOGGED_IN_NONE;
  98   if (delegate->IsScreenLocked())
  99     return user::LOGGED_IN_LOCKED;
 100   // TODO(nkostylev): Support LOGGED_IN_OWNER, LOGGED_IN_GUEST, LOGGED_IN_KIOSK,
 101   //                  LOGGED_IN_PUBLIC.
 102   return user::LOGGED_IN_USER;
 103 }
 104
 105 bool TestSystemTrayDelegate::IsOobeCompleted() const {
 106   return true;
 107 }
 108
 109 void TestSystemTrayDelegate::GetLoggedInUsers(UserEmailList* users) {
 110 }
 111
 112 void TestSystemTrayDelegate::SwitchActiveUser(const std::string& email) {
 113 }
 114
 115 void TestSystemTrayDelegate::ChangeProfilePicture() {
 116 }
 117
 118 const std::string TestSystemTrayDelegate::GetEnterpriseDomain() const {
 119   return std::string();
 120 }
 121
 122 const base::string16 TestSystemTrayDelegate::GetEnterpriseMessage() const {
 123   return string16();
 124 }
 125
 126 bool TestSystemTrayDelegate::SystemShouldUpgrade() const {
 127   return true;
 128 }
 129
 130 base::HourClockType TestSystemTrayDelegate::GetHourClockType() const {
 131   return base::k24HourClock;
 132 }
 133
 134 PowerSupplyStatus TestSystemTrayDelegate::GetPowerSupplyStatus() const {
 135   return PowerSupplyStatus();
 136 }
 137
 138 void TestSystemTrayDelegate::RequestStatusUpdate() const {
 139 }
 140
 141 void TestSystemTrayDelegate::ShowSettings() {
 142 }
 143
 144 void TestSystemTrayDelegate::ShowDateSettings() {
 145 }
 146
 147 void TestSystemTrayDelegate::ShowNetworkSettings() {
 148 }
 149
 150 void TestSystemTrayDelegate::ShowBluetoothSettings() {
 151 }
 152
 153 void TestSystemTrayDelegate::ShowDisplaySettings() {
 154 }
 155
 156 void TestSystemTrayDelegate::ShowDriveSettings() {
 157 }
 158
 159 void TestSystemTrayDelegate::ShowIMESettings() {
 160 }
 161
 162 void TestSystemTrayDelegate::ShowHelp() {
 163 }
 164
 165 void TestSystemTrayDelegate::ShowAccessibilityHelp() {
 166 }
 167
 168 void TestSystemTrayDelegate::ShowPublicAccountInfo() {
 169 }
 170
 171 void TestSystemTrayDelegate::ShowEnterpriseInfo() {
 172 }
 173
 174 void TestSystemTrayDelegate::ShowUserLogin() {
 175 }
 176
 177 void TestSystemTrayDelegate::ShutDown() {
 178   MessageLoop::current()->Quit();
 179 }
 180
 181 void TestSystemTrayDelegate::SignOut() {
 182   MessageLoop::current()->Quit();
 183 }
 184
 185 void TestSystemTrayDelegate::RequestLockScreen() {
 186 }
 187
 188 void TestSystemTrayDelegate::RequestRestart() {
 189 }
 190
 191 void TestSystemTrayDelegate::GetAvailableBluetoothDevices(
 192     BluetoothDeviceList* list) {
 193 }
 194
 195 void TestSystemTrayDelegate::BluetoothStartDiscovering() {
 196 }
 197
 198 void TestSystemTrayDelegate::BluetoothStopDiscovering() {
 199 }
 200
 201 void TestSystemTrayDelegate::ConnectToBluetoothDevice(
 202     const std::string& address) {
 203 }
 204
 205 void TestSystemTrayDelegate::GetCurrentIME(IMEInfo* info) {
 206 }
 207
 208 void TestSystemTrayDelegate::GetAvailableIMEList(IMEInfoList* list) {
 209 }
 210
 211 void TestSystemTrayDelegate::GetCurrentIMEProperties(
 212     IMEPropertyInfoList* list) {
 213 }
 214
 215 void TestSystemTrayDelegate::SwitchIME(const std::string& ime_id) {
 216 }
 217
 218 void TestSystemTrayDelegate::ActivateIMEProperty(const std::string& key) {
 219 }
 220
 221 void TestSystemTrayDelegate::CancelDriveOperation(const base::FilePath&) {
 222 }
 223
 224 void TestSystemTrayDelegate::GetDriveOperationStatusList(
 225     ash::DriveOperationStatusList*) {
 226 }
 227
 228 void TestSystemTrayDelegate::GetMostRelevantNetworkIcon(NetworkIconInfo* info,
 229                                                         bool large) {
 230 }
 231
 232 void TestSystemTrayDelegate::GetVirtualNetworkIcon(ash::NetworkIconInfo* info) {
 233 }
 234
 235 void TestSystemTrayDelegate::GetAvailableNetworks(
 236     std::vector<NetworkIconInfo>* list) {
 237 }
 238
 239 void TestSystemTrayDelegate::GetVirtualNetworks(
 240     std::vector<NetworkIconInfo>* list) {
 241 }
 242
 243 void TestSystemTrayDelegate::ConnectToNetwork(const std::string& network_id) {
 244 }
 245
 246 void TestSystemTrayDelegate::GetNetworkAddresses(
 247     std::string* ip_address,
 248     std::string* ethernet_mac_address,
 249     std::string* wifi_mac_address) {
 250   *ip_address = "127.0.0.1";
 251   *ethernet_mac_address = "00:11:22:33:44:55";
 252   *wifi_mac_address = "66:77:88:99:00:11";
 253 }
 254
 255 void TestSystemTrayDelegate::RequestNetworkScan() {
 256 }
 257
 258 void TestSystemTrayDelegate::AddBluetoothDevice() {
 259 }
 260
 261 void TestSystemTrayDelegate::ToggleAirplaneMode() {
 262 }
 263
 264 void TestSystemTrayDelegate::ToggleWifi() {
 265   wifi_enabled_ = !wifi_enabled_;
 266 }
 267
 268 void TestSystemTrayDelegate::ToggleMobile() {
 269   cellular_enabled_ = !cellular_enabled_;
 270 }
 271
 272 void TestSystemTrayDelegate::ToggleBluetooth() {
 273   bluetooth_enabled_ = !bluetooth_enabled_;
 274 }
 275
 276 bool TestSystemTrayDelegate::IsBluetoothDiscovering() {
 277   return false;
 278 }
 279
 280 void TestSystemTrayDelegate::ShowOtherWifi() {
 281 }
 282
 283 void TestSystemTrayDelegate::ShowOtherVPN() {
 284 }
 285
 286 void TestSystemTrayDelegate::ShowOtherCellular() {
 287 }
 288
 289 bool TestSystemTrayDelegate::IsNetworkConnected() {
 290   return true;
 291 }
 292
 293 bool TestSystemTrayDelegate::GetWifiAvailable() {
 294   return true;
 295 }
 296
 297 bool TestSystemTrayDelegate::GetMobileAvailable() {
 298   return true;
 299 }
 300
 301 bool TestSystemTrayDelegate::GetBluetoothAvailable() {
 302   return true;
 303 }
 304
 305 bool TestSystemTrayDelegate::GetWifiEnabled() {
 306   return wifi_enabled_;
 307 }
 308
 309 bool TestSystemTrayDelegate::GetMobileEnabled() {
 310   return cellular_enabled_;
 311 }
 312
 313 bool TestSystemTrayDelegate::GetBluetoothEnabled() {
 314   return bluetooth_enabled_;
 315 }
 316
 317 bool TestSystemTrayDelegate::GetMobileScanSupported() {
 318   return true;
 319 }
 320
 321 bool TestSystemTrayDelegate::GetCellularCarrierInfo(std::string* carrier_id,
 322                                                     std::string* topup_url,
 323                                                     std::string* setup_url) {
 324   return false;
 325 }
 326
 327 bool TestSystemTrayDelegate::GetWifiScanning() {
 328   return false;
 329 }
 330
 331 bool TestSystemTrayDelegate::GetCellularInitializing() {
 332   return false;
 333 }
 334
 335 void TestSystemTrayDelegate::ShowCellularURL(const std::string& url) {
 336 }
 337
 338 void TestSystemTrayDelegate::ChangeProxySettings() {
 339 }
 340
 341 VolumeControlDelegate* TestSystemTrayDelegate::GetVolumeControlDelegate()
 342     const {
 343   return volume_control_delegate_.get();
 344 }
 345
 346 void TestSystemTrayDelegate::SetVolumeControlDelegate(
 347     scoped_ptr<VolumeControlDelegate> delegate) {
 348   volume_control_delegate_ = delegate.Pass();
 349 }
 350
 351 bool TestSystemTrayDelegate::GetSessionStartTime(
 352     base::TimeTicks* session_start_time) {
 353   return false;
 354 }
 355
 356 bool TestSystemTrayDelegate::GetSessionLengthLimit(
 357      base::TimeDelta* session_length_limit) {
 358   return false;
 359 }
 360
 361 int TestSystemTrayDelegate::GetSystemTrayMenuWidth() {
 362   // This is the default width for English languages.
 363   return 300;
 364 }
 365
 366 base::string16 TestSystemTrayDelegate::FormatTimeDuration(
 367     const base::TimeDelta& delta) const {
 368   return base::string16();
 369 }
 370
 371 void TestSystemTrayDelegate::MaybeSpeak(const std::string& utterance) const {
 372 }
 373
 374 }  // namespace test
 375 }  // namespace ash