Add countdown when session time is limited

chrome/browser/chromeos/system/ash_system_tray_delegate.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 "chrome/browser/chromeos/system/ash_system_tray_delegate.h"
 
+#include <algorithm>
+
 #include "ash/shell.h"
 #include "ash/shell_delegate.h"
 #include "ash/shell_window_ids.h"
 #include "ash/system/audio/audio_observer.h"
 #include "ash/system/bluetooth/bluetooth_observer.h"
 #include "ash/system/brightness/brightness_observer.h"
 #include "ash/system/chromeos/network/network_observer.h"
 #include "ash/system/date/clock_observer.h"
 #include "ash/system/drive/drive_observer.h"
 #include "ash/system/ime/ime_observer.h"
 #include "ash/system/logout_button/logout_button_observer.h"
 #include "ash/system/power/power_status_observer.h"
 #include "ash/system/tray/system_tray.h"
 #include "ash/system/tray/system_tray_delegate.h"
 #include "ash/system/tray/system_tray_notifier.h"
 #include "ash/system/tray_accessibility.h"
 #include "ash/system/tray_caps_lock.h"
 #include "ash/system/user/update_observer.h"
 #include "ash/system/user/user_observer.h"
 #include "ash/volume_control_delegate.h"
 #include "ash/wm/session_state_controller.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
 #include "base/chromeos/chromeos_version.h"
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/memory/weak_ptr.h"
+#include "base/prefs/public/pref_service_base.h"
+#include "base/time.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/chromeos/accessibility/accessibility_util.h"
 #include "chrome/browser/chromeos/accessibility/magnification_manager.h"
 #include "chrome/browser/chromeos/audio/audio_handler.h"
 #include "chrome/browser/chromeos/cros/cros_library.h"
 #include "chrome/browser/chromeos/cros/network_library.h"
 #include "chrome/browser/chromeos/drive/drive_system_service.h"
 #include "chrome/browser/chromeos/input_method/input_method_configuration.h"
 #include "chrome/browser/chromeos/input_method/input_method_manager.h"
@@ skipping 42 matching lines @@
 #include "grit/generated_resources.h"
 #include "ui/base/l10n/l10n_util.h"
 
 using drive::DriveSystemService;
 using drive::DriveSystemServiceFactory;
 
 namespace chromeos {
 
 namespace {
 
+// The minimum session length limit that can be set.
+const int kSessionLengthLimitMinMs = 30 * 1000; // 30 seconds.
+
+// The maximum session length limit that can be set.
+const int kSessionLengthLimitMaxMs = 24 * 60 * 60 * 1000; // 24 hours.
+
 // Time delay for rechecking gdata operation when we suspect that there will
 // be no upcoming activity notifications that need to be pushed to UI.
 const int kGDataOperationRecheckDelayMs = 5000;
 
 ash::NetworkIconInfo CreateNetworkIconInfo(const Network* network,
                                            NetworkMenu* network_menu) {
   ash::NetworkIconInfo info;
   info.name = UTF8ToUTF16(network->name());
   info.image = NetworkMenuIcon::GetImage(network, NetworkMenuIcon::COLOR_DARK);
   info.service_path = network->service_path();
@@ skipping 128 matching lines @@
       SystemKeyEventListener::GetInstance()->AddCapsLockObserver(this);
 
     if (chromeos::MagnificationManager::Get())
       chromeos::MagnificationManager::Get()->AddObserver(this);
 
     network_icon_->SetResourceColorTheme(NetworkMenuIcon::COLOR_LIGHT);
     network_icon_dark_->SetResourceColorTheme(NetworkMenuIcon::COLOR_DARK);
 
     bluetooth_adapter_ = device::BluetoothAdapterFactory::DefaultAdapter();
     bluetooth_adapter_->AddObserver(this);
+
+    local_state_registrar_.Init(g_browser_process->local_state());
+
+    UpdateSessionStartTime();
+    UpdateSessionLengthLimit();
+
+    local_state_registrar_.Add(
+        prefs::kSessionStartTime,
+        base::Bind(&SystemTrayDelegate::UpdateSessionStartTime,
+                   base::Unretained(this)));
+    local_state_registrar_.Add(
+        prefs::kSessionLengthLimit,
+        base::Bind(&SystemTrayDelegate::UpdateSessionLengthLimit,
+                   base::Unretained(this)));
   }
 
   virtual ~SystemTrayDelegate() {
     AudioHandler* audiohandler = AudioHandler::GetInstance();
     if (audiohandler)
       audiohandler->RemoveVolumeObserver(this);
     DBusThreadManager::Get()->GetSessionManagerClient()->RemoveObserver(this);
     DBusThreadManager::Get()->GetRootPowerManagerClient()->RemoveObserver(this);
     DBusThreadManager::Get()->GetPowerManagerClient()->RemoveObserver(this);
     NetworkLibrary* crosnet = CrosLibrary::Get()->GetNetworkLibrary();
@@ skipping 511 matching lines @@
   virtual ash::VolumeControlDelegate* GetVolumeControlDelegate() const OVERRIDE
   {
     return volume_control_delegate_.get();
   }
 
   virtual void SetVolumeControlDelegate(
       scoped_ptr<ash::VolumeControlDelegate> delegate) OVERRIDE {
     volume_control_delegate_.swap(delegate);
   }
 
+  virtual base::Time GetSessionStartTime() OVERRIDE {
+    return session_start_time_;
+  }
+
+  virtual base::TimeDelta GetSessionLengthLimit() OVERRIDE {
+    return session_length_limit_;
+  }
+
  private:
   ash::SystemTray* GetPrimarySystemTray() {
     return ash::Shell::GetInstance()->GetPrimarySystemTray();
   }
 
   ash::SystemTrayNotifier* GetSystemTrayNotifier() {
     return ash::Shell::GetInstance()->system_tray_notifier();
   }
 
   // Returns the last active browser. If there is no such browser, creates a new
   // browser window with an empty tab and returns it.
   Browser* GetAppropriateBrowser() {
     return browser::FindOrCreateTabbedBrowser(
         ProfileManager::GetDefaultProfileOrOffTheRecord(),
         chrome::HOST_DESKTOP_TYPE_ASH);
   }
 
   void SetProfile(Profile* profile) {
     PrefService* prefs = profile->GetPrefs();
-    pref_registrar_.reset(new PrefChangeRegistrar);
-    pref_registrar_->Init(prefs);
-    pref_registrar_->Add(
+    user_pref_registrar_.reset(new PrefChangeRegistrar);
+    user_pref_registrar_->Init(prefs);
+    user_pref_registrar_->Add(
         prefs::kUse24HourClock,
         base::Bind(&SystemTrayDelegate::UpdateClockType,
                    base::Unretained(this)));
-    pref_registrar_->Add(
+    user_pref_registrar_->Add(
         prefs::kLanguageRemapSearchKeyTo,
         base::Bind(&SystemTrayDelegate::OnLanguageRemapSearchKeyToChanged,
                    base::Unretained(this)));
-    pref_registrar_->Add(
+    user_pref_registrar_->Add(
         prefs::kShowLogoutButtonInTray,
         base::Bind(&SystemTrayDelegate::UpdateShowLogoutButtonInTray,
                    base::Unretained(this)));
-    pref_registrar_->Add(
+    user_pref_registrar_->Add(
         prefs::kShouldAlwaysShowAccessibilityMenu,
         base::Bind(&SystemTrayDelegate::OnAccessibilityModeChanged,
                    base::Unretained(this),
                    ash::A11Y_NOTIFICATION_NONE));
 
     UpdateClockType();
     UpdateShowLogoutButtonInTray();
     search_key_mapped_to_ =
         profile->GetPrefs()->GetInteger(prefs::kLanguageRemapSearchKeyTo);
   }
 
   void ObserveGDataUpdates() {
     DriveSystemService* system_service = FindDriveSystemService();
     if (!system_service)
       return;
 
     system_service->drive_service()->AddObserver(this);
   }
 
   void UpdateClockType() {
-    clock_type_ = pref_registrar_->prefs()->GetBoolean(prefs::kUse24HourClock) ?
-        base::k24HourClock : base::k12HourClock;
+    clock_type_ =
+        user_pref_registrar_->prefs()->GetBoolean(prefs::kUse24HourClock) ?
+            base::k24HourClock : base::k12HourClock;
     GetSystemTrayNotifier()->NotifyDateFormatChanged();
   }
 
   void UpdateShowLogoutButtonInTray() {
     GetSystemTrayNotifier()->NotifyShowLoginButtonChanged(
-        pref_registrar_->prefs()->GetBoolean(prefs::kShowLogoutButtonInTray));
+        user_pref_registrar_->prefs()->GetBoolean(
+            prefs::kShowLogoutButtonInTray));
+  }
+
+  void UpdateSessionStartTime() {
+    session_start_time_ = base::Time::FromInternalValue(
+        local_state_registrar_.prefs()->GetInt64(prefs::kSessionStartTime));
+    GetSystemTrayNotifier()->NotifySessionStartTimeChanged(session_start_time_);
+  }
+
+  void UpdateSessionLengthLimit() {
+    const PrefServiceBase::Preference* session_length_limit_pref =
+        local_state_registrar_.prefs()->
+            FindPreference(prefs::kSessionLengthLimit);
+    int limit;
+    if (session_length_limit_pref->IsDefaultValue() ||
+        !session_length_limit_pref->GetValue()->GetAsInteger(&limit)) {
+      session_length_limit_ = base::TimeDelta();
+    } else {
+      session_length_limit_ = base::TimeDelta::FromMilliseconds(
+          std::min(std::max(limit, kSessionLengthLimitMinMs),
+              kSessionLengthLimitMaxMs));
+    }
+    GetSystemTrayNotifier()->NotifySessionLengthLimitChanged(
+        session_length_limit_);
   }
 
   void NotifyRefreshNetwork() {
     chromeos::NetworkLibrary* crosnet =
         chromeos::CrosLibrary::Get()->GetNetworkLibrary();
     const Network* network = crosnet->connected_network();
     ash::NetworkIconInfo info;
     if (network) {
       info.name = network->type() == TYPE_ETHERNET ?
           l10n_util::GetStringUTF16(IDS_STATUSBAR_NETWORK_DEVICE_ETHERNET) :
@@ skipping 231 matching lines @@
                 details).ptr();
         OnAccessibilityModeChanged(accessibility_status->notify);
         break;
       }
       default:
         NOTREACHED();
     }
   }
 
   void OnLanguageRemapSearchKeyToChanged() {
-    search_key_mapped_to_ = pref_registrar_->prefs()->GetInteger(
+    search_key_mapped_to_ = user_pref_registrar_->prefs()->GetInteger(
         prefs::kLanguageRemapSearchKeyTo);
   }
 
   void OnAccessibilityModeChanged(
       ash::AccessibilityNotificationVisibility notify) {
     GetSystemTrayNotifier()->NotifyAccessibilityModeChanged(notify);
   }
 
   // Overridden from InputMethodManager::Observer.
   virtual void InputMethodChanged(
@@ skipping 141 matching lines @@
   // Overridden from MagnificationObserver
   void OnMagnifierTypeChanged(ash::MagnifierType new_type) {
     OnAccessibilityModeChanged(ash::A11Y_NOTIFICATION_NONE);
   }
 
   scoped_ptr<base::WeakPtrFactory<SystemTrayDelegate> > ui_weak_ptr_factory_;
   scoped_ptr<NetworkMenuIcon> network_icon_;
   scoped_ptr<NetworkMenuIcon> network_icon_dark_;
   scoped_ptr<NetworkMenu> network_menu_;
   content::NotificationRegistrar registrar_;
-  scoped_ptr<PrefChangeRegistrar> pref_registrar_;
+  PrefChangeRegistrar local_state_registrar_;
+  scoped_ptr<PrefChangeRegistrar> user_pref_registrar_;
   std::string cellular_device_path_;
   std::string active_network_path_;
   PowerSupplyStatus power_supply_status_;
   base::HourClockType clock_type_;
   int search_key_mapped_to_;
   bool screen_locked_;
+  base::Time session_start_time_;
+  base::TimeDelta session_length_limit_;
 
   scoped_refptr<device::BluetoothAdapter> bluetooth_adapter_;
 
   scoped_ptr<DataPromoNotification> data_promo_notification_;
 
   scoped_ptr<ash::VolumeControlDelegate> volume_control_delegate_;
 
   DISALLOW_COPY_AND_ASSIGN(SystemTrayDelegate);
 };
 
 }  // namespace
 
 ash::SystemTrayDelegate* CreateSystemTrayDelegate() {
   return new chromeos::SystemTrayDelegate();
 }
 
 }  // namespace chromeos