chromeos: Convert system tray session length limit to mojo

ash/system/session/tray_session_length_limit.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/session/tray_session_length_limit.h"
 
 #include <algorithm>
 #include <memory>
 #include <utility>
 
 #include "ash/resources/vector_icons/vector_icons.h"
+#include "ash/session/session_controller.h"
 #include "ash/shell.h"
 #include "ash/strings/grit/ash_strings.h"
 #include "ash/system/system_notifier.h"
 #include "ash/system/tray/label_tray_view.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/tray_constants.h"
 #include "base/logging.h"
 #include "base/strings/utf_string_conversions.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/l10n/time_format.h"
 #include "ui/gfx/paint_vector_icon.h"
 #include "ui/message_center/message_center.h"
 #include "ui/message_center/notification.h"
 #include "ui/views/view.h"
@@ skipping 14 matching lines @@
 
 // static
 const char TraySessionLengthLimit::kNotificationId[] =
     "chrome://session/timeout";
 
 TraySessionLengthLimit::TraySessionLengthLimit(SystemTray* system_tray)
     : SystemTrayItem(system_tray, UMA_SESSION_LENGTH_LIMIT),
       limit_state_(LIMIT_NONE),
       last_limit_state_(LIMIT_NONE),
       tray_bubble_view_(nullptr) {
-  Shell::Get()->system_tray_notifier()->AddSessionLengthLimitObserver(this);
+  Shell::Get()->session_controller()->AddObserver(this);
   Update();
 }
 
 TraySessionLengthLimit::~TraySessionLengthLimit() {
-  Shell::Get()->system_tray_notifier()->RemoveSessionLengthLimitObserver(this);
+  Shell::Get()->session_controller()->RemoveObserver(this);
 }
 
 // Add view to tray bubble.
 views::View* TraySessionLengthLimit::CreateDefaultView(LoginStatus status) {
   CHECK(!tray_bubble_view_);
   UpdateState();
   if (limit_state_ == LIMIT_NONE)
     return nullptr;
   tray_bubble_view_ = new LabelTrayView(nullptr, kSystemMenuTimerIcon);
   tray_bubble_view_->SetMessage(ComposeTrayBubbleMessage());
   return tray_bubble_view_;
 }
 
 // View has been removed from tray bubble.
 void TraySessionLengthLimit::OnDefaultViewDestroyed() {
   tray_bubble_view_ = nullptr;
 }
 
-void TraySessionLengthLimit::OnSessionStartTimeChanged() {
-  Update();
-}
-
 void TraySessionLengthLimit::OnSessionLengthLimitChanged() {
   Update();
 }
 
 void TraySessionLengthLimit::Update() {
   UpdateState();
   UpdateNotification();
   UpdateTrayBubbleView();
 }
 
 void TraySessionLengthLimit::UpdateState() {
-  SystemTrayDelegate* delegate = Shell::Get()->system_tray_delegate();
-  if (delegate->GetSessionStartTime(&session_start_time_) &&
-      delegate->GetSessionLengthLimit(&time_limit_)) {

[James Cook, 2017/06/05 23:23:48]

As far as I can tell there was never a need for the boolean return values of
these Get() methods. The UI is only relevant when there is a non-zero length
limit and a non-null start time, and the implementation code in chrome always
fills in both.

[msw, 2017/06/06 19:01:04]

Acknowledged.

+  SessionController* session = Shell::Get()->session_controller();
+  base::TimeDelta time_limit = session->session_length_limit();
+  base::TimeTicks session_start_time = session->session_start_time();
+  if (!time_limit.is_zero() && !session_start_time.is_null()) {
     const base::TimeDelta expiring_soon_threshold(
         base::TimeDelta::FromMinutes(kExpiringSoonThresholdInMinutes));
     remaining_session_time_ =
-        std::max(time_limit_ - (base::TimeTicks::Now() - session_start_time_),
+        std::max(time_limit - (base::TimeTicks::Now() - session_start_time),
                  base::TimeDelta());
     limit_state_ = remaining_session_time_ <= expiring_soon_threshold
                        ? LIMIT_EXPIRING_SOON
                        : LIMIT_SET;
     if (!timer_)
       timer_.reset(new base::RepeatingTimer);
     if (!timer_->IsRunning()) {
       timer_->Start(FROM_HERE, base::TimeDelta::FromMilliseconds(
                                    kTimerIntervalInMilliseconds),
                     this, &TraySessionLengthLimit::Update);
@@ skipping 41 matching lines @@
           base::string16() /* title */,
           ComposeNotificationMessage() /* message */,
           gfx::Image(
               gfx::CreateVectorIcon(kSystemMenuTimerIcon, kMenuIconColor)),
           base::string16() /* display_source */, GURL(),
           message_center::NotifierId(
               message_center::NotifierId::SYSTEM_COMPONENT,
               system_notifier::kNotifierSessionLengthTimeout),
           data, nullptr /* delegate */));
   notification->SetSystemPriority();
-  if (message_center->FindVisibleNotificationById(kNotificationId))
+  if (message_center->FindVisibleNotificationById(kNotificationId)) {
     message_center->UpdateNotification(kNotificationId,
                                        std::move(notification));
-  else
+  } else {
     message_center->AddNotification(std::move(notification));
+  }
   last_limit_state_ = limit_state_;
 }
 
 void TraySessionLengthLimit::UpdateTrayBubbleView() const {
   if (!tray_bubble_view_)
     return;
   if (limit_state_ == LIMIT_NONE)
     tray_bubble_view_->SetMessage(base::string16());
   else
     tray_bubble_view_->SetMessage(ComposeTrayBubbleMessage());
@@ skipping 10 matching lines @@
 
 base::string16 TraySessionLengthLimit::ComposeTrayBubbleMessage() const {
   return l10n_util::GetStringFUTF16(
       IDS_ASH_STATUS_TRAY_BUBBLE_SESSION_LENGTH_LIMIT,
       ui::TimeFormat::Detailed(ui::TimeFormat::FORMAT_DURATION,
                                ui::TimeFormat::LENGTH_LONG, 10,
                                remaining_session_time_));
 }
 
 }  // namespace ash