Show media router toolbar icon ephemerally for active local routes and issues

chrome/browser/ui/toolbar/media_router_action.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 "chrome/browser/ui/toolbar/media_router_action.h"
 
 #include "base/metrics/user_metrics.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/media/router/issue.h"
 #include "chrome/browser/media/router/media_route.h"
@@ skipping 23 matching lines @@
 }
 
 }  // namespace
 
 MediaRouterAction::MediaRouterAction(Browser* browser,
                                      ToolbarActionsBar* toolbar_actions_bar)
     : media_router::IssuesObserver(GetMediaRouter(browser)),
       media_router::MediaRoutesObserver(GetMediaRouter(browser)),
       current_icon_(gfx::VectorIconId::MEDIA_ROUTER_IDLE),
       has_local_display_route_(false),
+      has_dialog_(false),
       delegate_(nullptr),
       browser_(browser),
       toolbar_actions_bar_(toolbar_actions_bar),
       platform_delegate_(MediaRouterActionPlatformDelegate::Create(browser)),
       contextual_menu_(browser),
       tab_strip_model_observer_(this),
+      toolbar_actions_bar_observer_(this),
       weak_ptr_factory_(this) {
   DCHECK(browser_);
   DCHECK(toolbar_actions_bar_);
   tab_strip_model_observer_.Add(browser_->tab_strip_model());
-
+  toolbar_actions_bar_observer_.Add(toolbar_actions_bar_);
   RegisterObserver();
 }
 
 MediaRouterAction::~MediaRouterAction() {
   UnregisterObserver();
 }
 
 std::string MediaRouterAction::GetId() const {
   return ComponentToolbarActionsFactory::kMediaRouterActionId;
 }
 
 void MediaRouterAction::SetDelegate(ToolbarActionViewDelegate* delegate) {
   delegate_ = delegate;
 
-  // Updates the current popup state if |delegate_| is non-null and has
-  // WebContents ready.
   // In cases such as opening a new browser window, SetDelegate() will be
-  // called before the WebContents is set. In those cases, we update the popup
-  // state when ActiveTabChanged() is called.
+  // called before the WebContents is set. In those cases, we register with the
+  // dialog controller when ActiveTabChanged() is called.
   if (delegate_ && delegate_->GetCurrentWebContents())
-    UpdatePopupState();
+    RegisterWithDialogController();
 }
 
 gfx::Image MediaRouterAction::GetIcon(content::WebContents* web_contents,
                                       const gfx::Size& size) {
   // Color is defined in the icon.
   return gfx::Image(
       gfx::CreateVectorIcon(current_icon_, gfx::kPlaceholderColor));
 }
 
 base::string16 MediaRouterAction::GetActionName() const {
@@ skipping 20 matching lines @@
   return false;
 }
 
 bool MediaRouterAction::HasPopup(
     content::WebContents* web_contents) const {
   return true;
 }
 
 void MediaRouterAction::HidePopup() {
   GetMediaRouterDialogController()->HideMediaRouterDialog();
-  OnPopupHidden();
 }
 
 gfx::NativeView MediaRouterAction::GetPopupNativeView() {
   return nullptr;
 }
 
 ui::MenuModel* MediaRouterAction::GetContextMenu() {
   return contextual_menu_.menu_model();
 }
 
 bool MediaRouterAction::ExecuteAction(bool by_user) {
   base::RecordAction(base::UserMetricsAction("MediaRouter_Icon_Click"));
 
   if (GetMediaRouterDialogController()->IsShowingMediaRouterDialog()) {
     GetMediaRouterDialogController()->HideMediaRouterDialog();
     return false;
   }
 
   GetMediaRouterDialogController()->ShowMediaRouterDialog();
   if (GetPlatformDelegate()) {
     media_router::MediaRouterMetrics::RecordMediaRouterDialogOrigin(
         GetPlatformDelegate()->CloseOverflowMenuIfOpen() ?
         media_router::MediaRouterDialogOpenOrigin::OVERFLOW_MENU :
         media_router::MediaRouterDialogOpenOrigin::TOOLBAR);
   }
   return true;
 }
 
 void MediaRouterAction::UpdateState() {
-  if (delegate_)
-    delegate_->UpdateState();
+  DCHECK(delegate_);

[msw, 2016/09/21 15:40:59]

nit: no need to dcheck right before deref

[takumif, 2016/09/21 17:08:18]

Removed.

+  delegate_->UpdateState();
 }
 
 bool MediaRouterAction::DisabledClickOpensMenu() const {
   return false;
 }
 
 void MediaRouterAction::OnIssueUpdated(const media_router::Issue* issue) {
   issue_.reset(issue ? new media_router::Issue(*issue) : nullptr);
-
   MaybeUpdateIcon();
 }
 
 void MediaRouterAction::OnRoutesUpdated(
     const std::vector<media_router::MediaRoute>& routes,
     const std::vector<media_router::MediaRoute::Id>& joinable_route_ids) {
   has_local_display_route_ =
       std::find_if(routes.begin(), routes.end(),
                    [](const media_router::MediaRoute& route) {
                      return route.is_local() && route.for_display();
                    }) != routes.end();
   MaybeUpdateIcon();
 }
 
 void MediaRouterAction::ActiveTabChanged(content::WebContents* old_contents,
                                          content::WebContents* new_contents,
                                          int index,
                                          int reason) {
-  UpdatePopupState();
+  RegisterWithDialogController();
+  UpdateDialogState();
 }
 
-void MediaRouterAction::OnPopupHidden() {
-  if (delegate_)
-    delegate_->OnPopupClosed();
+void MediaRouterAction::OnToolbarActionsBarAnimationEnded() {
+  // Depress the action if the dialog is shown.

[msw, 2016/09/21 15:40:59]

nit: just call UpdateDialogState()?

[takumif, 2016/09/21 17:08:18]

Done.

+  DCHECK(delegate_);
+  if (GetMediaRouterDialogController()->IsShowingMediaRouterDialog())
+    OnDialogShown();
 }
 
-void MediaRouterAction::OnPopupShown() {
-  // We depress the action regardless of whether ExecuteAction() was user
-  // initiated.
-  if (delegate_)
-    delegate_->OnPopupShown(true);
+void MediaRouterAction::OnDialogHidden() {
+  if (has_dialog_) {
+    has_dialog_ = false;
+    delegate_->OnPopupClosed();
+  }
 }
 
-void MediaRouterAction::UpdatePopupState() {
+void MediaRouterAction::OnDialogShown() {
+  if (!has_dialog_) {
+    has_dialog_ = true;
+    // We depress the action regardless of whether ExecuteAction() was user
+    // initiated.
+    delegate_->OnPopupShown(true);
+  }
+}
+
+void MediaRouterAction::RegisterWithDialogController() {
   MediaRouterDialogControllerImpl* controller =
       GetMediaRouterDialogController();
 
   if (!controller)
     return;
 
-  // When each browser window is created, its toolbar creates a
-  // MediaRouterAction that is only destroyed when the browser window is torn
-  // down. |controller| will keep track of that instance. If |this| was created
-  // in overflow mode, it will be destroyed when the overflow menu is closed.
-  // If SetMediaRouterAction() was previously called, this is a no-op.
+  // |controller| keeps track of |this| if |this| was created with the browser
+  // window or ephemerally by activating the Cast functionality. If |this| was
+  // created in overflow mode, it will be destroyed when the overflow menu is
+  // closed.
   if (!toolbar_actions_bar_->in_overflow_mode())
     controller->SetMediaRouterAction(weak_ptr_factory_.GetWeakPtr());
+}
 
-  // Update the button in case the pressed state is out of sync with dialog
-  // visibility.
-  if (controller->IsShowingMediaRouterDialog())
-    OnPopupShown();
+void MediaRouterAction::UpdateDialogState() {
+  if (GetMediaRouterDialogController()->IsShowingMediaRouterDialog())
+    OnDialogShown();
   else
-    OnPopupHidden();
+    OnDialogHidden();
 }
 
 MediaRouterDialogControllerImpl*
 MediaRouterAction::GetMediaRouterDialogController() {
   DCHECK(delegate_);
   content::WebContents* web_contents = delegate_->GetCurrentWebContents();
   DCHECK(web_contents);
   return MediaRouterDialogControllerImpl::GetOrCreateForWebContents(
       web_contents);
 }
 
 MediaRouterActionPlatformDelegate* MediaRouterAction::GetPlatformDelegate() {
   return platform_delegate_.get();
 }
 
 void MediaRouterAction::MaybeUpdateIcon() {
   gfx::VectorIconId new_icon = GetCurrentIcon();
 
   // Update the current state if it has changed.
   if (new_icon != current_icon_) {
     current_icon_ = new_icon;
 
     // Tell the associated view to update its icon to reflect the change made
-    // above.
+    // above. If MaybeUpdateIcon() was called as a result of instantiating
+    // |this|, then |delegate_| may not be set yet.
     if (delegate_)
-      delegate_->UpdateState();
+      UpdateState();
   }
 }
 
 gfx::VectorIconId MediaRouterAction::GetCurrentIcon() const {
   // Highest priority is to indicate whether there's an issue.
   if (issue_) {
     if (issue_->severity() == media_router::Issue::FATAL)
       return gfx::VectorIconId::MEDIA_ROUTER_ERROR;
     if (issue_->severity() == media_router::Issue::WARNING)
       return gfx::VectorIconId::MEDIA_ROUTER_WARNING;
   }
 
   return has_local_display_route_ ? gfx::VectorIconId::MEDIA_ROUTER_ACTIVE
                                   : gfx::VectorIconId::MEDIA_ROUTER_IDLE;
 }