MediaRouterAction: Only observe Media Routes when there is a local route.

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/strings/utf_string_conversions.h"
 #include "chrome/browser/media/router/issue.h"
 #include "chrome/browser/media/router/media_route.h"
 #include "chrome/browser/media/router/media_router.h"
 #include "chrome/browser/media/router/media_router_factory.h"
 #include "chrome/browser/media/router/media_router_mojo_impl.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/tabs/tab_strip_model.h"
 #include "chrome/browser/ui/toolbar/component_toolbar_actions_factory.h"
 #include "chrome/browser/ui/toolbar/media_router_action_platform_delegate.h"
 #include "chrome/browser/ui/toolbar/toolbar_action_view_delegate.h"
 #include "chrome/browser/ui/webui/media_router/media_router_dialog_controller_impl.h"
 #include "chrome/grit/generated_resources.h"
 #include "grit/theme_resources.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "ui/gfx/image/image_skia.h"
 
 using media_router::MediaRouterDialogControllerImpl;
 
+namespace {
+
+media_router::MediaRouter* GetMediaRouter(Browser* browser) {
+  return media_router::MediaRouterFactory::GetApiForBrowserContext(
+      browser->profile());
+}
+
+}  // namespace
+
 MediaRouterAction::MediaRouterAction(Browser* browser)
     : media_router::IssuesObserver(GetMediaRouter(browser)),
-      media_router::MediaRoutesObserver(GetMediaRouter(browser)),
+      media_router::LocalMediaRoutesObserver(GetMediaRouter(browser)),
       media_router_active_icon_(
           ui::ResourceBundle::GetSharedInstance()
               .GetImageNamed(IDR_MEDIA_ROUTER_ACTIVE_ICON)),
       media_router_error_icon_(ui::ResourceBundle::GetSharedInstance()
                                    .GetImageNamed(IDR_MEDIA_ROUTER_ERROR_ICON)),
       media_router_idle_icon_(ui::ResourceBundle::GetSharedInstance()
                                   .GetImageNamed(IDR_MEDIA_ROUTER_IDLE_ICON)),
       media_router_warning_icon_(
           ui::ResourceBundle::GetSharedInstance()
               .GetImageNamed(IDR_MEDIA_ROUTER_WARNING_ICON)),
       current_icon_(&media_router_idle_icon_),
       has_local_route_(false),
       delegate_(nullptr),
       browser_(browser),
       platform_delegate_(MediaRouterActionPlatformDelegate::Create(browser)),
       contextual_menu_(browser),
       tab_strip_model_observer_(this),
       weak_ptr_factory_(this) {
   DCHECK(browser_);
   tab_strip_model_observer_.Add(browser_->tab_strip_model());
+  SetHasLocalRoute(GetMediaRouter(browser)->GetHasLocalRoute());
 }
 
 MediaRouterAction::~MediaRouterAction() {
 }
 
 std::string MediaRouterAction::GetId() const {
   return ComponentToolbarActionsFactory::kMediaRouterActionId;
 }
 
 void MediaRouterAction::SetDelegate(ToolbarActionViewDelegate* delegate) {
@@ skipping 70 matching lines @@
 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) {
-  has_local_route_ =
-      std::find_if(routes.begin(), routes.end(),
-                   [](const media_router::MediaRoute& route) {
-                      return route.is_local(); }) !=
-      routes.end();
-  MaybeUpdateIcon();
+void MediaRouterAction::UpdateHasLocalRoute(bool has_local_route) {

[imcheng, 2015/10/02 17:21:11]

It seems to me that this method is not needed. Callers of this method can just
call SetHasLocalRoute.

[apacible, 2015/10/02 18:48:20]

UpdateHasLocalRoute (now OnHasLocalRouteUpdated) is for the
LocalMediaRoutesObserver, so I removed SetHasLocalRoute instead.

+  SetHasLocalRoute(has_local_route);
 }
 
 void MediaRouterAction::ActiveTabChanged(content::WebContents* old_contents,
                                          content::WebContents* new_contents,
                                          int index,
                                          int reason) {
   UpdatePopupState();
 }
 
 void MediaRouterAction::OnPopupHidden() {
   if (delegate_)
     delegate_->OnPopupClosed();
 }
 
 void MediaRouterAction::OnPopupShown() {
   // We depress the action regardless of whether ExecuteAction() was user
   // initiated.
   if (delegate_)
     delegate_->OnPopupShown(true);
 }
 
+void MediaRouterAction::SetHasLocalRoute(bool has_local_route) {
+  has_local_route_ = has_local_route;
+  MaybeUpdateIcon();
+}
+
 void MediaRouterAction::UpdatePopupState() {
   MediaRouterDialogControllerImpl* controller =
       GetMediaRouterDialogController();
 
   if (!controller)
     return;
 
   // Immediately keep track of MediaRouterAction in the controller. If it was
   // already set, this should be a no-op.
   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();
   else
     OnPopupHidden();
 }
 
 MediaRouterDialogControllerImpl*
 MediaRouterAction::GetMediaRouterDialogController() {
   DCHECK(delegate_);
   content::WebContents* web_contents = delegate_->GetCurrentWebContents();
   DCHECK(web_contents);
   return MediaRouterDialogControllerImpl::GetOrCreateForWebContents(
       web_contents);
 }
 
-media_router::MediaRouter* MediaRouterAction::GetMediaRouter(Browser* browser) {
-  return media_router::MediaRouterFactory::GetApiForBrowserContext(
-      static_cast<content::BrowserContext*>(browser->profile()));
-}
-
 MediaRouterActionPlatformDelegate* MediaRouterAction::GetPlatformDelegate() {
   return platform_delegate_.get();
 }
 
 void MediaRouterAction::MaybeUpdateIcon() {
   const gfx::Image* new_icon = GetCurrentIcon();
 
   // Update the current state if it has changed.
   if (new_icon != current_icon_) {
     current_icon_ = new_icon;
@@ skipping 10 matching lines @@
   if (issue_) {
     if (issue_->severity() == media_router::Issue::FATAL)
       return &media_router_error_icon_;
     if (issue_->severity() == media_router::Issue::WARNING)
       return &media_router_warning_icon_;
   }
 
   return has_local_route_ ?
       &media_router_active_icon_ : &media_router_idle_icon_;
 }