Make the ChromeOS chromecast system tray integration use a private API.

ash/system/cast/tray_cast.cc

 // Copyright 2015 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/cast/tray_cast.h"
 
 #include "ash/session/session_state_delegate.h"
 #include "ash/shelf/shelf_types.h"
 #include "ash/shell.h"
 #include "ash/system/chromeos/screen_security/screen_tray_item.h"
@@ skipping 18 matching lines @@
 #include "ui/views/controls/button/button.h"
 #include "ui/views/controls/image_view.h"
 #include "ui/views/controls/label.h"
 #include "ui/views/layout/box_layout.h"
 #include "ui/views/layout/fill_layout.h"
 
 namespace ash {
 
 namespace {
 const int kStopButtonRightPadding = 18;
+
+// Returns the active CastConfigDelegate instance.
+ash::CastConfigDelegate* GetCastConfigDelegate() {
+  return ash::Shell::GetInstance()
+      ->system_tray_delegate()
+      ->GetCastConfigDelegate();
+}
 }  // namespace
 
 namespace tray {
 
 // This view is displayed in the system tray when the cast extension is active.
 // It asks the user if they want to cast the desktop. If they click on the
 // chevron, then a detail view will replace this view where the user will
 // actually pick the cast receiver.
 class CastSelectDefaultView : public TrayItemMore {
  public:
   CastSelectDefaultView(SystemTrayItem* owner,
-                        CastConfigDelegate* cast_config_delegate,
                         bool show_more);
   ~CastSelectDefaultView() override;
 
-  // Updates the label based on the current set of receivers (if there are or
-  // are not any available receivers).
-  void UpdateLabel();
-
  private:
-  void UpdateLabelCallback(
-      const CastConfigDelegate::ReceiversAndActivites& receivers_activities);
-
-  CastConfigDelegate* cast_config_delegate_;
-  base::WeakPtrFactory<CastSelectDefaultView> weak_ptr_factory_;
   DISALLOW_COPY_AND_ASSIGN(CastSelectDefaultView);
 };
 
-CastSelectDefaultView::CastSelectDefaultView(
-    SystemTrayItem* owner,
-    CastConfigDelegate* cast_config_delegate,
-    bool show_more)
-    : TrayItemMore(owner, show_more),
-      cast_config_delegate_(cast_config_delegate),
-      weak_ptr_factory_(this) {
+CastSelectDefaultView::CastSelectDefaultView(SystemTrayItem* owner,
+                                             bool show_more)
+    : TrayItemMore(owner, show_more) {
   ui::ResourceBundle& rb = ui::ResourceBundle::GetSharedInstance();
+
+  // Update the image and label.
   SetImage(rb.GetImageNamed(IDR_AURA_UBER_TRAY_CAST).ToImageSkia());
-
-  // We first set a default label before we actually know what the label will
-  // be, because it could take awhile before UpdateLabel() actually applies
-  // the correct label.
-  SetLabel(rb.GetLocalizedString(IDS_ASH_STATUS_TRAY_CAST_NO_DEVICE));
-  UpdateLabel();
+  base::string16 label =
+      rb.GetLocalizedString(IDS_ASH_STATUS_TRAY_CAST_DESKTOP);
+  SetLabel(label);
+  SetAccessibleName(label);
 }
 
-CastSelectDefaultView::~CastSelectDefaultView() {
-}
-
-void CastSelectDefaultView::UpdateLabelCallback(
-    const CastConfigDelegate::ReceiversAndActivites& receivers_activities) {
-  // The label needs to reflect if there are no cast receivers
-  const base::string16 label =
-      ui::ResourceBundle::GetSharedInstance().GetLocalizedString(
-          receivers_activities.empty() ? IDS_ASH_STATUS_TRAY_CAST_NO_DEVICE
-                                       : IDS_ASH_STATUS_TRAY_CAST_DESKTOP);
-  SetLabel(label);
-  SetAccessibleName(label);
-  SetVisible(true);
-}
-
-void CastSelectDefaultView::UpdateLabel() {
-  if (cast_config_delegate_ == nullptr ||
-      cast_config_delegate_->HasCastExtension() == false)
-    return;
-
-  cast_config_delegate_->GetReceiversAndActivities(
-      base::Bind(&CastSelectDefaultView::UpdateLabelCallback,
-                 weak_ptr_factory_.GetWeakPtr()));
-}
+CastSelectDefaultView::~CastSelectDefaultView() {}
 
 // This view is displayed when the screen is actively being casted; it allows
 // the user to easily stop casting. It fully replaces the
 // |CastSelectDefaultView| view inside of the |CastDuplexView|.
 class CastCastView : public views::View, public views::ButtonListener {
  public:
-  explicit CastCastView(CastConfigDelegate* cast_config_delegate);
+  CastCastView();
   ~CastCastView() override;
 
   void StopCasting();
 
   // Updates the label for the stop view to include information about the
   // current device that is being casted.
-  void UpdateLabel();
+  void UpdateLabel(
+      const CastConfigDelegate::ReceiversAndActivites& receivers_activities);
 
  private:
-  void UpdateLabelCallback(
-      const CastConfigDelegate::ReceiversAndActivites& receivers_activities);
-
   // Overridden from views::View.
   int GetHeightForWidth(int width) const override;
   void Layout() override;
 
   // Overridden from views::ButtonListener.
   void ButtonPressed(views::Button* sender, const ui::Event& event) override;
 
-  CastConfigDelegate* cast_config_delegate_;
   views::ImageView* icon_;
   views::Label* label_;
   TrayPopupLabelButton* stop_button_;
   base::WeakPtrFactory<CastCastView> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(CastCastView);
 };
 
-CastCastView::CastCastView(CastConfigDelegate* cast_config_delegate)
-    : cast_config_delegate_(cast_config_delegate), weak_ptr_factory_(this) {
+CastCastView::CastCastView() : weak_ptr_factory_(this) {
   // We will initialize the primary tray view which shows a stop button here.
 
   set_background(views::Background::CreateSolidBackground(kBackgroundColor));
   ui::ResourceBundle& bundle = ui::ResourceBundle::GetSharedInstance();
   SetLayoutManager(new views::BoxLayout(views::BoxLayout::kHorizontal,
                                         kTrayPopupPaddingHorizontal, 0,
                                         kTrayPopupPaddingBetweenItems));
   icon_ = new FixedSizedImageView(0, kTrayPopupItemHeight);
   icon_->SetImage(
       bundle.GetImageNamed(IDR_AURA_UBER_TRAY_CAST_ENABLED).ToImageSkia());
   AddChildView(icon_);
 
   // The label which describes both what we are casting (ie, the desktop) and
   // where we are casting it to.
   label_ = new views::Label;
   label_->SetHorizontalAlignment(gfx::ALIGN_LEFT);
   label_->SetMultiLine(true);
   label_->SetText(
       bundle.GetLocalizedString(IDS_ASH_STATUS_TRAY_CAST_CAST_UNKNOWN));
   AddChildView(label_);
 
   // Add the stop bottom on the far-right. We customize how this stop button is
   // displayed inside of |Layout()|.
   base::string16 stop_button_text =
       ui::ResourceBundle::GetSharedInstance().GetLocalizedString(
           IDS_ASH_STATUS_TRAY_CAST_STOP);
   stop_button_ = new TrayPopupLabelButton(this, stop_button_text);
   AddChildView(stop_button_);
-
-  UpdateLabel();
 }
 
 CastCastView::~CastCastView() {
 }
 
 int CastCastView::GetHeightForWidth(int width) const {
   // We are reusing the cached label_->bounds() calculation which was
   // done inside of Layout(). Due to the way this object is initialized,
   // Layout() will always get initially invoked with the dummy text
   // (which will compute the proper label width) and then when we know
@@ skipping 17 matching lines @@
   // Adjust the label's bounds in case it got cut off by |stop_button_|.
   if (label_->bounds().Intersects(stop_button_->bounds())) {
     gfx::Rect label_bounds = label_->bounds();
     label_bounds.set_width(stop_button_->x() - kTrayPopupPaddingBetweenItems -
                            label_->x());
     label_->SetBoundsRect(label_bounds);
   }
 }
 
 void CastCastView::StopCasting() {
-  cast_config_delegate_->StopCasting();
+  GetCastConfigDelegate()->StopCasting();
   Shell::GetInstance()->metrics()->RecordUserMetricsAction(
       ash::UMA_STATUS_AREA_CAST_STOP_CAST);
 }
 
-void CastCastView::UpdateLabel() {
-  if (cast_config_delegate_ == nullptr ||
-      cast_config_delegate_->HasCastExtension() == false)
-    return;
-
-  cast_config_delegate_->GetReceiversAndActivities(base::Bind(
-      &CastCastView::UpdateLabelCallback, weak_ptr_factory_.GetWeakPtr()));
-}
-
-void CastCastView::UpdateLabelCallback(
+void CastCastView::UpdateLabel(
     const CastConfigDelegate::ReceiversAndActivites& receivers_activities) {
   for (auto& i : receivers_activities) {
-    const CastConfigDelegate::Receiver receiver = i.second.receiver;
-    const CastConfigDelegate::Activity activity = i.second.activity;
+    const CastConfigDelegate::Receiver& receiver = i.receiver;
+    const CastConfigDelegate::Activity& activity = i.activity;
     if (!activity.id.empty()) {
       // We want to display different labels inside of the title depending on
       // what we are actually casting - either the desktop, a tab, or a fallback
       // that catches everything else (ie, an extension tab).
       if (activity.tab_id == CastConfigDelegate::Activity::TabId::DESKTOP) {
         label_->SetText(l10n_util::GetStringFUTF16(
             IDS_ASH_STATUS_TRAY_CAST_CAST_DESKTOP, receiver.name));
       } else if (activity.tab_id >= 0) {
         label_->SetText(l10n_util::GetStringFUTF16(
             IDS_ASH_STATUS_TRAY_CAST_CAST_TAB, activity.title, receiver.name));
@@ skipping 13 matching lines @@
                                  const ui::Event& event) {
   DCHECK(sender == stop_button_);
   StopCasting();
 }
 
 // This view by itself does very little. It acts as a front-end for managing
 // which of the two child views (|CastSelectDefaultView| and |CastCastView|)
 // is active.
 class CastDuplexView : public views::View {
  public:
-  CastDuplexView(SystemTrayItem* owner,
-                 CastConfigDelegate* config_delegate,
-                 bool show_more);
+  CastDuplexView(
+      SystemTrayItem* owner,
+      bool show_more,
+      const CastConfigDelegate::ReceiversAndActivites& receivers_activities);
   ~CastDuplexView() override;
 
   // Activate either the casting or select view.
   void ActivateCastView();
   void ActivateSelectView();
 
   CastSelectDefaultView* select_view() { return select_view_; }
   CastCastView* cast_view() { return cast_view_; }
 
  private:
   // Overridden from views::View.
   void ChildPreferredSizeChanged(views::View* child) override;
   void Layout() override;
 
   // Only one of |select_view_| or |cast_view_| will be displayed at any given
   // time. This will return the view is being displayed.
   views::View* ActiveChildView();
 
   CastSelectDefaultView* select_view_;
   CastCastView* cast_view_;
 
   DISALLOW_COPY_AND_ASSIGN(CastDuplexView);
 };
 
-CastDuplexView::CastDuplexView(SystemTrayItem* owner,
-                               CastConfigDelegate* config_delegate,
-                               bool show_more) {
-  select_view_ = new CastSelectDefaultView(owner, config_delegate, show_more);
-  cast_view_ = new CastCastView(config_delegate);
+CastDuplexView::CastDuplexView(
+    SystemTrayItem* owner,
+    bool show_more,
+    const CastConfigDelegate::ReceiversAndActivites& receivers_activities) {
+  select_view_ = new CastSelectDefaultView(owner, show_more);
+  cast_view_ = new CastCastView();
+  cast_view_->UpdateLabel(receivers_activities);
   SetLayoutManager(new views::FillLayout());
 
   ActivateSelectView();
 }
 
 CastDuplexView::~CastDuplexView() {
   RemoveChildView(ActiveChildView());
   delete select_view_;
   delete cast_view_;
 }
@@ skipping 77 matching lines @@
   SetLayoutManager(new views::BoxLayout(layout, 0, 0, 0));
   Layout();
 }
 
 // This view displays a list of cast receivers that can be clicked on and casted
 // to. It is activated by clicking on the chevron inside of
 // |CastSelectDefaultView|.
 class CastDetailedView : public TrayDetailsView, public ViewClickListener {
  public:
   CastDetailedView(SystemTrayItem* owner,
-                   CastConfigDelegate* cast_config_delegate,
-                   user::LoginStatus login);
+                   user::LoginStatus login,
+                   const CastConfigDelegate::ReceiversAndActivites&
+                       receivers_and_activities);
   ~CastDetailedView() override;
 
   // Makes the detail view think the view associated with the given receiver_id
   // was clicked. This will start a cast.
   void SimulateViewClickedForTest(const std::string& receiver_id);
 
+  // Updates the list of available receivers.
+  void UpdateReceiverList(const CastConfigDelegate::ReceiversAndActivites&
+                              new_receivers_and_activities);
+
  private:
   void CreateItems();
 
-  void UpdateReceiverList();
-  void UpdateReceiverListCallback(
-      const CastConfigDelegate::ReceiversAndActivites&
-          new_receivers_and_activities);
   void UpdateReceiverListFromCachedData();
   views::View* AddToReceiverList(
       const CastConfigDelegate::ReceiverAndActivity& receiverActivity);
 
   void AppendSettingsEntries();
   void AppendHeaderEntry();
 
   // Overridden from ViewClickListener.
   void OnViewClicked(views::View* sender) override;
 
-  CastConfigDelegate* cast_config_delegate_;
   user::LoginStatus login_;
   views::View* options_ = nullptr;
-  CastConfigDelegate::ReceiversAndActivites receivers_and_activities_;
-  // A mapping from the view pointer to the associated activity id
+  // A mapping from the receiver id to the receiver/activity data.
+  std::map<std::string, CastConfigDelegate::ReceiverAndActivity>
+      receivers_and_activities_;
+  // A mapping from the view pointer to the associated activity id.
   std::map<views::View*, std::string> receiver_activity_map_;
   base::WeakPtrFactory<CastDetailedView> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(CastDetailedView);
 };
 
-CastDetailedView::CastDetailedView(SystemTrayItem* owner,
-                                   CastConfigDelegate* cast_config_delegate,
-                                   user::LoginStatus login)
-    : TrayDetailsView(owner),
-      cast_config_delegate_(cast_config_delegate),
-      login_(login),
-      weak_ptr_factory_(this) {
+CastDetailedView::CastDetailedView(
+    SystemTrayItem* owner,
+    user::LoginStatus login,
+    const CastConfigDelegate::ReceiversAndActivites& receivers_and_activities)
+    : TrayDetailsView(owner), login_(login), weak_ptr_factory_(this) {
   CreateItems();
-  UpdateReceiverList();
+  UpdateReceiverList(receivers_and_activities);
 }
 
 CastDetailedView::~CastDetailedView() {
 }
 
 void CastDetailedView::SimulateViewClickedForTest(
     const std::string& receiver_id) {
   for (auto& it : receiver_activity_map_) {
     if (it.second == receiver_id) {
       OnViewClicked(it.first);
       break;
     }
   }
 }
 
 void CastDetailedView::CreateItems() {
   CreateScrollableList();
   AppendSettingsEntries();
   AppendHeaderEntry();
 }
 
-void CastDetailedView::UpdateReceiverList() {
-  cast_config_delegate_->GetReceiversAndActivities(
-      base::Bind(&CastDetailedView::UpdateReceiverListCallback,
-                 weak_ptr_factory_.GetWeakPtr()));
-}
-
-void CastDetailedView::UpdateReceiverListCallback(
+void CastDetailedView::UpdateReceiverList(
     const CastConfigDelegate::ReceiversAndActivites&
         new_receivers_and_activities) {
   // Add/update existing.
   for (auto i = new_receivers_and_activities.begin();
        i != new_receivers_and_activities.end(); ++i) {
-    receivers_and_activities_[i->first] = i->second;
+    receivers_and_activities_[i->receiver.id] = *i;
   }
-  // Remove non-existent.
-  for (auto i = receivers_and_activities_.begin();
-       i != receivers_and_activities_.end(); ++i) {
-    if (new_receivers_and_activities.count(i->first) == 0)
-      receivers_and_activities_.erase(i->first);
+
+  // Remove non-existent receivers. Removing an element invalidates all existing
+  // iterators.
+  auto i = receivers_and_activities_.begin();
+  while (i != receivers_and_activities_.end()) {
+    bool has_receiver = false;
+    for (auto receiver : new_receivers_and_activities) {
+      if (i->first == receiver.receiver.id)
+        has_receiver = true;
+    }
+
+    if (has_receiver)
+      ++i;
+    else
+      i = receivers_and_activities_.erase(i);
   }
 
   // Update UI.
   UpdateReceiverListFromCachedData();
   Layout();
 }
 
 void CastDetailedView::UpdateReceiverListFromCachedData() {
   // Remove all of the existing views.
   receiver_activity_map_.clear();
@@ skipping 43 matching lines @@
 
   AddChildView(container);
   options_ = container;
 }
 
 void CastDetailedView::AppendHeaderEntry() {
   CreateSpecialRow(IDS_ASH_STATUS_TRAY_CAST, this);
 }
 
 void CastDetailedView::OnViewClicked(views::View* sender) {
+  ash::CastConfigDelegate* cast_config_delegate = GetCastConfigDelegate();
+
   if (sender == footer()->content()) {
     TransitionToDefaultView();
   } else if (sender == options_) {
-    cast_config_delegate_->LaunchCastOptions();
+    cast_config_delegate->LaunchCastOptions();
   } else {
     // Find the receiver we are going to cast to
     auto it = receiver_activity_map_.find(sender);
     if (it != receiver_activity_map_.end()) {
-      cast_config_delegate_->CastToReceiver(it->second);
+      cast_config_delegate->CastToReceiver(it->second);
       Shell::GetInstance()->metrics()->RecordUserMetricsAction(
           ash::UMA_STATUS_AREA_DETAILED_CAST_VIEW_LAUNCH_CAST);
     }
   }
 }
 
 }  // namespace tray
 
 TrayCast::TrayCast(SystemTray* system_tray)
     : SystemTrayItem(system_tray),
-      cast_config_delegate_(ash::Shell::GetInstance()
-                                ->system_tray_delegate()
-                                ->GetCastConfigDelegate()),
       weak_ptr_factory_(this) {
   Shell::GetInstance()->AddShellObserver(this);
 }
 
 TrayCast::~TrayCast() {
   Shell::GetInstance()->RemoveShellObserver(this);
 }
 
 void TrayCast::StartCastForTest(const std::string& receiver_id) {
   if (detailed_ != nullptr)
@@ skipping 11 matching lines @@
 views::View* TrayCast::CreateTrayView(user::LoginStatus status) {
   CHECK(tray_ == nullptr);
   tray_ = new tray::CastTrayView(this);
   tray_->SetVisible(is_casting_);
   return tray_;
 }
 
 views::View* TrayCast::CreateDefaultView(user::LoginStatus status) {
   CHECK(default_ == nullptr);
 
-  default_ = new tray::CastDuplexView(this, cast_config_delegate_,
-                                      status != user::LOGGED_IN_LOCKED);
+  if (HasCastExtension()) {
+    ash::CastConfigDelegate* cast_config_delegate = GetCastConfigDelegate();
+
+    // We add the cast listener here instead of in the ctor for two reasons:
+    // - The ctor gets called too early in the initialization cycle (at least
+    //   for the tests); the correct profile hasn't been setup yet.
+    // - The listener is only added if there is a cast extension. If the call
+    //   below were in the ctor, then the cast tray item would not appear if the
+    //   user installed the extension in an existing session.
+    if (!device_update_subscription_) {
+      device_update_subscription_ =
+          cast_config_delegate->RegisterDeviceUpdateObserver(base::Bind(
+              &TrayCast::OnReceiversUpdated, weak_ptr_factory_.GetWeakPtr()));
+    }
+
+    // The extension updates its view model whenever the popup is opened, so we
+    // probably should as well.
+    cast_config_delegate->RequestDeviceRefresh();
+  }
+
+  default_ = new tray::CastDuplexView(this, status != user::LOGGED_IN_LOCKED,
+                                      receivers_and_activities_);
   default_->set_id(TRAY_VIEW);
   default_->select_view()->set_id(SELECT_VIEW);
   default_->cast_view()->set_id(CAST_VIEW);
 
   UpdatePrimaryView();
   return default_;
 }
 
 views::View* TrayCast::CreateDetailedView(user::LoginStatus status) {
   Shell::GetInstance()->metrics()->RecordUserMetricsAction(
       ash::UMA_STATUS_AREA_DETAILED_CAST_VIEW);
   CHECK(detailed_ == nullptr);
-  detailed_ = new tray::CastDetailedView(this, cast_config_delegate_, status);
+  detailed_ =
+      new tray::CastDetailedView(this, status, receivers_and_activities_);
   return detailed_;
 }
 
 void TrayCast::DestroyTrayView() {
   tray_ = nullptr;
 }
 
 void TrayCast::DestroyDefaultView() {
   default_ = nullptr;
 }
 
 void TrayCast::DestroyDetailedView() {
   detailed_ = nullptr;
 }
 
 bool TrayCast::HasCastExtension() {
-  return cast_config_delegate_ != nullptr &&
-         cast_config_delegate_->HasCastExtension();
+  ash::CastConfigDelegate* cast_config_delegate = GetCastConfigDelegate();
+  return cast_config_delegate != nullptr &&
+         cast_config_delegate->HasCastExtension();
 }
 
-void TrayCast::UpdateCachedReceiverState(
+void TrayCast::OnReceiversUpdated(
     const CastConfigDelegate::ReceiversAndActivites& receivers_activities) {
-  has_cast_receivers_ = !receivers_activities.empty();
-  if (default_)
-    default_->SetVisible(has_cast_receivers_);
+  receivers_and_activities_ = receivers_activities;
+
+  if (default_) {
+    bool has_receivers = !receivers_and_activities_.empty();
+    default_->SetVisible(has_receivers);
+    default_->cast_view()->UpdateLabel(receivers_and_activities_);
+  }
+  if (detailed_)
+    detailed_->UpdateReceiverList(receivers_and_activities_);
 }
 
 void TrayCast::UpdatePrimaryView() {
   if (HasCastExtension()) {
     if (default_) {
-      if (is_casting_) {
+      if (is_casting_)
         default_->ActivateCastView();
-      } else {
+      else
         default_->ActivateSelectView();
-
-        // We only want to show the select view if we have a receiver we can
-        // cast to. To prevent showing the tray item and then hiding it some
-        // short time after, we cache if we have any receivers. We set our
-        // default visibility to true if we do have a receiver, false otherwise.
-        default_->SetVisible(has_cast_receivers_);
-        cast_config_delegate_->GetReceiversAndActivities(
-            base::Bind(&TrayCast::UpdateCachedReceiverState,
-                       weak_ptr_factory_.GetWeakPtr()));
-      }
     }
 
     if (tray_)
       tray_->SetVisible(is_casting_);
   } else {
     if (default_)
       default_->SetVisible(false);
     if (tray_)
       tray_->SetVisible(false);
   }
 }
 
 void TrayCast::OnCastingSessionStartedOrStopped(bool started) {
   is_casting_ = started;
   UpdatePrimaryView();
 }
 
 void TrayCast::UpdateAfterShelfAlignmentChange(ShelfAlignment alignment) {
   if (tray_)
     tray_->UpdateAlignment(alignment);
 }
 
 }  // namespace ash