Remove Chromecast extension support from cast system tray menu.

ash/common/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/common/system/cast/tray_cast.h"
 
 #include "ash/common/material_design/material_design_controller.h"
 #include "ash/common/session/session_state_delegate.h"
 #include "ash/common/shelf/wm_shelf_util.h"
 #include "ash/common/system/chromeos/screen_security/screen_tray_item.h"
@@ skipping 27 matching lines @@
 
 namespace ash {
 
 namespace {
 
 const size_t kMaximumStatusStringLength = 100;
 const int kStopButtonRightPadding = 18;
 
 // Returns the active CastConfigDelegate instance.
 CastConfigDelegate* GetCastConfigDelegate() {
-  return WmShell::Get()->system_tray_delegate()->GetCastConfigDelegate();
+  ash::SystemTrayDelegate* delegate = WmShell::Get()->system_tray_delegate();
+  if (!delegate)

[achuithb, 2016/10/27 19:38:59]

Seems like a good place for the ternary operator:
return delegate ? delegate->GetCastConfigDelegate() : nullptr;

[jdufault, 2016/10/31 21:12:08]

Done.

+    return nullptr;
+  return delegate->GetCastConfigDelegate();
 }
 
 // Helper method to elide the given string to the maximum length. If a string is
 // contains user-input and is displayed, we should elide it.
 // TODO(jdufault): This does not properly trim unicode characters. We should
 // implement this properly by using views::Label::SetElideBehavior(...). See
 // crbug.com/532496.
 base::string16 ElideString(const base::string16& text) {
   base::string16 elided;
   gfx::ElideString(text, kMaximumStatusStringLength, &elided);
@@ skipping 47 matching lines @@
 // 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:
   CastCastView();
   ~CastCastView() override;
 
   void StopCasting();
 
   const std::string& displayed_activity_id() const {
-    return displayed_activity_id_;
+    return displayed_route_.id;
   }
 
   // Updates the label for the stop view to include information about the
   // current device that is being casted.
-  void UpdateLabel(
-      const CastConfigDelegate::ReceiversAndActivities& receivers_activities);
+  void UpdateLabel(const CastConfigDelegate::SinksAndRoutes& sinks_routes);
 
  private:
   // 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;
 
   // The cast activity id that we are displaying. If the user stops a cast, we
   // send this value to the config delegate so that we stop the right cast.
-  std::string displayed_activity_id_;
+  CastConfigDelegate::Route displayed_route_;
 
   views::ImageView* icon_;
   views::Label* label_;
   TrayPopupLabelButton* stop_button_;
 
   DISALLOW_COPY_AND_ASSIGN(CastCastView);
 };
 
 CastCastView::CastCastView() {
   // We will initialize the primary tray view which shows a stop button here.
@@ skipping 57 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() {
-  GetCastConfigDelegate()->StopCasting(displayed_activity_id_);
+  GetCastConfigDelegate()->StopCasting(displayed_route_);
   WmShell::Get()->RecordUserMetricsAction(UMA_STATUS_AREA_CAST_STOP_CAST);
 }
 
 void CastCastView::UpdateLabel(
-    const CastConfigDelegate::ReceiversAndActivities& receivers_activities) {
-  for (auto& i : receivers_activities) {
-    const CastConfigDelegate::Receiver& receiver = i.receiver;
-    const CastConfigDelegate::Activity& activity = i.activity;
+    const CastConfigDelegate::SinksAndRoutes& sinks_routes) {
+  for (auto& i : sinks_routes) {
+    const CastConfigDelegate::Sink& sink = i.sink;
+    const CastConfigDelegate::Route& route = i.route;
 
-    if (!activity.id.empty()) {
-      displayed_activity_id_ = activity.id;
+    if (!route.id.empty()) {
+      displayed_route_ = route;
 
       // 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(ElideString(l10n_util::GetStringFUTF16(
-            IDS_ASH_STATUS_TRAY_CAST_CAST_DESKTOP, receiver.name)));
-      } else if (activity.tab_id >= 0) {
-        label_->SetText(ElideString(l10n_util::GetStringFUTF16(
-            IDS_ASH_STATUS_TRAY_CAST_CAST_TAB, activity.title, receiver.name)));
-      } else {
-        label_->SetText(
-            l10n_util::GetStringUTF16(IDS_ASH_STATUS_TRAY_CAST_CAST_UNKNOWN));
+      switch (route.content_source) {
+        case CastConfigDelegate::Route::ContentSource::UNKNOWN:
+          label_->SetText(
+              l10n_util::GetStringUTF16(IDS_ASH_STATUS_TRAY_CAST_CAST_UNKNOWN));
+          break;
+        case CastConfigDelegate::Route::ContentSource::TAB:
+          label_->SetText(ElideString(l10n_util::GetStringFUTF16(
+              IDS_ASH_STATUS_TRAY_CAST_CAST_TAB, route.title, sink.name)));
+          break;
+        case CastConfigDelegate::Route::ContentSource::DESKTOP:
+          label_->SetText(ElideString(l10n_util::GetStringFUTF16(
+              IDS_ASH_STATUS_TRAY_CAST_CAST_DESKTOP, sink.name)));
+          break;

[achuithb, 2016/10/27 19:38:59]

I believe 
default:
  NOTREACHED() << "unhandled source";
is customary?

[jdufault, 2016/10/31 21:12:07]

Not having default means the compiler will emit a warning if an enum entry is
added to ContentSource but not handled here.

It looks like this is allowed by the style guide.

https://google.github.io/styleguide/cppguide.html#Loops_and_Switch_Statements

       }
 
       PreferredSizeChanged();
       Layout();
 
       // If this machine is the source of the activity, then we want to display
       // it over any other activity. There can be multiple activities if other
       // devices on the network are casting at the same time.
-      if (activity.is_local_source)
+      if (route.is_local_source)
         break;
     }
   }
 }
 
 void CastCastView::ButtonPressed(views::Button* sender,
                                  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,
-      bool show_more,
-      const CastConfigDelegate::ReceiversAndActivities& receivers_activities);
+  CastDuplexView(SystemTrayItem* owner,
+                 bool show_more,
+                 const CastConfigDelegate::SinksAndRoutes& sinks_routes);
   ~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,
     bool show_more,
-    const CastConfigDelegate::ReceiversAndActivities& receivers_activities) {
+    const CastConfigDelegate::SinksAndRoutes& sinks_routes) {
   select_view_ = new CastSelectDefaultView(owner, show_more);
   cast_view_ = new CastCastView();
-  cast_view_->UpdateLabel(receivers_activities);
+  cast_view_->UpdateLabel(sinks_routes);
   SetLayoutManager(new views::FillLayout());
 
   ActivateSelectView();
 }
 
 CastDuplexView::~CastDuplexView() {
   RemoveChildView(ActiveChildView());
   delete select_view_;
   delete cast_view_;
 }
@@ skipping 72 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:
   CastDetailedView(SystemTrayItem* owner,
-                   LoginStatus login,
-                   const CastConfigDelegate::ReceiversAndActivities&
-                       receivers_and_activities);
+                   const CastConfigDelegate::SinksAndRoutes& sinks_routes);
   ~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::ReceiversAndActivities&
-                              new_receivers_and_activities);
+  void UpdateReceiverList(
+      const CastConfigDelegate::SinksAndRoutes& sinks_routes);
 
  private:
   void CreateItems();
 
   void UpdateReceiverListFromCachedData();
   views::View* AddToReceiverList(
-      const CastConfigDelegate::ReceiverAndActivity& receiverActivity);
-
-  void AppendSettingsEntries();
+      const CastConfigDelegate::SinkAndRoute& sink_route);
 
   // TrayDetailsView:
   void HandleViewClicked(views::View* view) override;
 
-  LoginStatus login_;
-  views::View* options_ = nullptr;
   // A mapping from the receiver id to the receiver/activity data.
-  std::map<std::string, CastConfigDelegate::ReceiverAndActivity>
-      receivers_and_activities_;
+  std::map<std::string, CastConfigDelegate::SinkAndRoute> sinks_and_routes_;
   // A mapping from the view pointer to the associated activity id.
-  std::map<views::View*, std::string> receiver_activity_map_;
+  std::map<views::View*, CastConfigDelegate::Sink> view_to_sink_map_;
 
   DISALLOW_COPY_AND_ASSIGN(CastDetailedView);
 };
 
 CastDetailedView::CastDetailedView(
     SystemTrayItem* owner,
-    LoginStatus login,
-    const CastConfigDelegate::ReceiversAndActivities& receivers_and_activities)
-    : TrayDetailsView(owner), login_(login) {
+    const CastConfigDelegate::SinksAndRoutes& sinks_routes)
+    : TrayDetailsView(owner) {
   CreateItems();
-  UpdateReceiverList(receivers_and_activities);
+  UpdateReceiverList(sinks_routes);
 }
 
 CastDetailedView::~CastDetailedView() {}
 
 void CastDetailedView::SimulateViewClickedForTest(
     const std::string& receiver_id) {
-  for (auto& it : receiver_activity_map_) {
-    if (it.second == receiver_id) {
+  for (const auto& it : view_to_sink_map_) {
+    if (it.second.id == receiver_id) {
       HandleViewClicked(it.first);
       break;
     }
   }
 }
 
 void CastDetailedView::CreateItems() {
   CreateScrollableList();
-  if (GetCastConfigDelegate()->HasOptions())
-    AppendSettingsEntries();
   CreateTitleRow(IDS_ASH_STATUS_TRAY_CAST);
 }
 
 void CastDetailedView::UpdateReceiverList(
-    const CastConfigDelegate::ReceiversAndActivities&
-        new_receivers_and_activities) {
+    const CastConfigDelegate::SinksAndRoutes& sinks_routes) {
   // Add/update existing.
-  for (auto i = new_receivers_and_activities.begin();
-       i != new_receivers_and_activities.end(); ++i) {
-    receivers_and_activities_[i->receiver.id] = *i;
+  for (const auto& it : sinks_routes) {
+    sinks_and_routes_[it.sink.id] = it;
   }
 
   // Remove non-existent receivers. Removing an element invalidates all existing
   // iterators.
-  auto i = receivers_and_activities_.begin();
-  while (i != receivers_and_activities_.end()) {
+  auto i = sinks_and_routes_.begin();
+  while (i != sinks_and_routes_.end()) {
     bool has_receiver = false;
-    for (auto receiver : new_receivers_and_activities) {
-      if (i->first == receiver.receiver.id)
+    for (auto receiver : sinks_routes) {
+      if (i->first == receiver.sink.id)
         has_receiver = true;
     }
 
     if (has_receiver)
       ++i;
     else
-      i = receivers_and_activities_.erase(i);
+      i = sinks_and_routes_.erase(i);
   }
 
   // Update UI.
   UpdateReceiverListFromCachedData();
   Layout();
 }
 
 void CastDetailedView::UpdateReceiverListFromCachedData() {
   // Remove all of the existing views.
-  receiver_activity_map_.clear();
+  view_to_sink_map_.clear();
   scroll_content()->RemoveAllChildViews(true);
 
   // Add a view for each receiver.
-  for (auto& it : receivers_and_activities_) {
-    const CastConfigDelegate::ReceiverAndActivity& receiver_activity =
-        it.second;
-    views::View* container = AddToReceiverList(receiver_activity);
-    receiver_activity_map_[container] = it.first;
+  for (auto& it : sinks_and_routes_) {
+    const CastConfigDelegate::SinkAndRoute& sink_route = it.second;
+    views::View* container = AddToReceiverList(sink_route);
+    view_to_sink_map_[container] = sink_route.sink;
   }
 
   scroll_content()->SizeToPreferredSize();
   static_cast<views::View*>(scroller())->Layout();
 }
 
 views::View* CastDetailedView::AddToReceiverList(
-    const CastConfigDelegate::ReceiverAndActivity& receiverActivity) {
-  HoverHighlightView* container = new HoverHighlightView(this);
-
+    const CastConfigDelegate::SinkAndRoute& sink_route) {
   const gfx::ImageSkia* image =
       ui::ResourceBundle::GetSharedInstance()
           .GetImageNamed(IDR_AURA_UBER_TRAY_CAST_DEVICE_ICON)
           .ToImageSkia();
-  const base::string16& name = receiverActivity.receiver.name;
+  HoverHighlightView* container = new HoverHighlightView(this);
   container->AddIconAndLabelCustomSize(
-      *image, name, false, kTrayPopupDetailsIconWidth,
+      *image, sink_route.sink.name, false, kTrayPopupDetailsIconWidth,
       kTrayPopupPaddingHorizontal, kTrayPopupPaddingBetweenItems);
 
   scroll_content()->AddChildView(container);
   return container;
 }
 
-void CastDetailedView::AppendSettingsEntries() {
-  if (MaterialDesignController::IsSystemTrayMenuMaterial())
-    return;
-
-  // Settings requires a browser window, hide it for non logged in user.
-  if (login_ == LoginStatus::NOT_LOGGED_IN || login_ == LoginStatus::LOCKED ||
-      WmShell::Get()->GetSessionStateDelegate()->IsInSecondaryLoginScreen()) {
-    return;
-  }
-
-  ui::ResourceBundle& rb = ui::ResourceBundle::GetSharedInstance();
-  HoverHighlightView* container = new HoverHighlightView(this);
-  container->AddLabel(rb.GetLocalizedString(IDS_ASH_STATUS_TRAY_CAST_OPTIONS),
-                      gfx::ALIGN_LEFT, false /* highlight */);
-
-  AddChildView(container);
-  options_ = container;
-}
-
 void CastDetailedView::HandleViewClicked(views::View* view) {
-  if (view == options_) {
-    GetCastConfigDelegate()->LaunchCastOptions();
-    return;
-  }
-
   // Find the receiver we are going to cast to.
-  auto it = receiver_activity_map_.find(view);
-  if (it != receiver_activity_map_.end()) {
+  auto it = view_to_sink_map_.find(view);
+  if (it != view_to_sink_map_.end()) {
     GetCastConfigDelegate()->CastToReceiver(it->second);
     WmShell::Get()->RecordUserMetricsAction(
         UMA_STATUS_AREA_DETAILED_CAST_VIEW_LAUNCH_CAST);
   }
 }
 
 }  // namespace tray
 
 TrayCast::TrayCast(SystemTray* system_tray)
     : SystemTrayItem(system_tray, UMA_CAST) {
   WmShell::Get()->AddShellObserver(this);
+
+  CastConfigDelegate* cast_config_delegate = GetCastConfigDelegate();
+  if (cast_config_delegate) {

[achuithb, 2016/10/27 19:38:59]

When is this not true?

[jdufault, 2016/10/31 21:12:08]

Some unrelated tests do not fully initialize everything.

+    cast_config_delegate->AddObserver(this);
+    cast_config_delegate->RequestDeviceRefresh();
+  }
 }
 
 TrayCast::~TrayCast() {
+  CastConfigDelegate* cast_config_delegate = GetCastConfigDelegate();
+  if (cast_config_delegate)
+    cast_config_delegate->RemoveObserver(this);
+
   WmShell::Get()->RemoveShellObserver(this);
-  if (added_observer_)
-    GetCastConfigDelegate()->RemoveObserver(this);
 }
 
 void TrayCast::StartCastForTest(const std::string& receiver_id) {
   if (detailed_ != nullptr)
     detailed_->SimulateViewClickedForTest(receiver_id);
 }
 
 void TrayCast::StopCastForTest() {
   default_->cast_view()->StopCasting();
 }
 
 const std::string& TrayCast::GetDisplayedCastId() {
   return default_->cast_view()->displayed_activity_id();
 }
 
 const views::View* TrayCast::GetDefaultView() const {
   return default_;
 }
 
 views::View* TrayCast::CreateTrayView(LoginStatus status) {
   CHECK(tray_ == nullptr);
   tray_ = new tray::CastTrayView(this);
-  tray_->SetVisible(is_casting_);
+  tray_->SetVisible(HasActiveRoute());
   return tray_;
 }
 
 views::View* TrayCast::CreateDefaultView(LoginStatus status) {
   CHECK(default_ == nullptr);
 
-  if (HasCastExtension()) {
-    CastConfigDelegate* cast_config_delegate = GetCastConfigDelegate();
-
-    // Add the cast observer here instead of 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.
-    // - If we're using the cast extension backend (media router is disabled),
-    //   then the user can install the extension at any point in time. The
-    //   return value of HasCastExtension() can change, so only checking it in
-    //   the ctor isn't enough.
-    if (!added_observer_) {
-      cast_config_delegate->AddObserver(this);
-      added_observer_ = true;
-    }
-
-    // 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 != LoginStatus::LOCKED,
-                                      receivers_and_activities_);
+                                      sinks_and_routes_);
   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(LoginStatus status) {
   WmShell::Get()->RecordUserMetricsAction(UMA_STATUS_AREA_DETAILED_CAST_VIEW);
   CHECK(detailed_ == nullptr);
-  detailed_ =
-      new tray::CastDetailedView(this, status, receivers_and_activities_);
+  detailed_ = new tray::CastDetailedView(this, sinks_and_routes_);
   return detailed_;
 }
 
 void TrayCast::DestroyTrayView() {
   tray_ = nullptr;
 }
 
 void TrayCast::DestroyDefaultView() {
   default_ = nullptr;
 }
 
 void TrayCast::DestroyDetailedView() {
   detailed_ = nullptr;
 }
 
-bool TrayCast::HasCastExtension() {
-  CastConfigDelegate* cast_config_delegate = GetCastConfigDelegate();
-  return cast_config_delegate != nullptr &&
-         cast_config_delegate->HasCastExtension();
-}
-
 void TrayCast::OnDevicesUpdated(
-    const CastConfigDelegate::ReceiversAndActivities& receivers_activities) {
-  receivers_and_activities_ = receivers_activities;
+    const CastConfigDelegate::SinksAndRoutes& sinks_routes) {
+  sinks_and_routes_ = sinks_routes;
+  UpdatePrimaryView();
 
   if (default_) {
-    bool has_receivers = !receivers_and_activities_.empty();
+    bool has_receivers = !sinks_and_routes_.empty();
     default_->SetVisible(has_receivers);
-    default_->cast_view()->UpdateLabel(receivers_and_activities_);
+    default_->cast_view()->UpdateLabel(sinks_and_routes_);
   }
   if (detailed_)
-    detailed_->UpdateReceiverList(receivers_and_activities_);
+    detailed_->UpdateReceiverList(sinks_and_routes_);
 }
 
 void TrayCast::UpdatePrimaryView() {
-  if (HasCastExtension() && !receivers_and_activities_.empty()) {
+  if (!sinks_and_routes_.empty()) {
     if (default_) {
-      if (is_casting_)
+      if (HasActiveRoute())
         default_->ActivateCastView();
       else
         default_->ActivateSelectView();
     }
 
     if (tray_)
-      tray_->SetVisible(is_casting_);
+      tray_->SetVisible(is_mirror_casting_);
   } else {
     if (default_)
       default_->SetVisible(false);
     if (tray_)
       tray_->SetVisible(false);
   }
 }
 
+bool TrayCast::HasActiveRoute() {
+  if (is_mirror_casting_)
+    return true;
+
+  for (const auto& sr : sinks_and_routes_) {
+    if (!sr.route.title.empty())
+      return true;
+  }
+
+  return false;
+}
+
 void TrayCast::OnCastingSessionStartedOrStopped(bool started) {
-  is_casting_ = started;
+  is_mirror_casting_ = started;
   UpdatePrimaryView();
 }
 
 void TrayCast::UpdateAfterShelfAlignmentChange(ShelfAlignment alignment) {
   if (tray_)
     tray_->UpdateAlignment(alignment);
 }
 
 }  // namespace ash