Reflect the current state in Media Router Action icon.

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_dialog_controller.h"
+#include "chrome/browser/media/router/media_router_factory.h"
+#include "chrome/browser/media/router/media_router_mojo_impl.h"
 #include "chrome/browser/ui/toolbar/media_router_action_platform_delegate.h"
 #include "chrome/browser/ui/toolbar/toolbar_action_view_delegate.h"
 #include "chrome/grit/generated_resources.h"
+#include "content/public/browser/web_contents.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::MediaRouterDialogController;
 
+MediaRouterActionObserver::MediaRouterActionObserver(
+    media_router::MediaRouter* router,
+    MediaRouterAction* action)
+    : media_router::IssuesObserver(router),
+      media_router::MediaRoutesObserver(router),
+      action_(action) {
+  DCHECK(router);
+  DCHECK(action);
+}
+
+MediaRouterActionObserver::~MediaRouterActionObserver() {}
+
+void MediaRouterActionObserver::OnIssueUpdated(
+    const media_router::Issue* issue) {
+  action_->SetCurrentIssue(issue);
+}
+
+void MediaRouterActionObserver::OnRoutesUpdated(
+    const std::vector<media_router::MediaRoute>& routes) {
+  // Check if any of the routes are local.
+  auto it = std::find_if(routes.begin(), routes.end(),
+                         [](const media_router::MediaRoute& route) {
+                             return route.is_local();
+                         });
+
+  action_->SetHasLocalRoutes(it != routes.end());
+}
+
 MediaRouterAction::MediaRouterAction(Browser* browser)
     : id_("media_router_action"),
       name_(l10n_util::GetStringUTF16(IDS_MEDIA_ROUTER_TITLE)),
+      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)),
+      state_(MEDIA_ROUTER_ACTION_IDLE),
+      issue_(nullptr),
+      has_local_routes_(false),
       delegate_(nullptr),
       platform_delegate_(MediaRouterActionPlatformDelegate::Create(browser)),
       contextual_menu_(browser) {
 }
 
 MediaRouterAction::~MediaRouterAction() {
 }
 
 const std::string& MediaRouterAction::GetId() const {
   return id_;
 }
 
 void MediaRouterAction::SetDelegate(ToolbarActionViewDelegate* delegate) {
   delegate_ = delegate;
+
+  if (delegate_) {
+    media_router::MediaRouter* media_router = GetMediaRouter();
+    if (media_router)

[Kevin M, 2015/08/03 17:15:37]

You can DCHECK for this, but it's a pretty sure thing that the MediaRouter is
available. :)

[apacible, 2015/08/03 20:47:22]

Acknowledged.

+      action_observer_.reset(new MediaRouterActionObserver(media_router, this));
+  } else {
+    action_observer_.reset();
+  }
 }
 
 gfx::Image MediaRouterAction::GetIcon(content::WebContents* web_contents,
                                       const gfx::Size& size) {
-  // TODO(apacible): Return icon based on casting state.
-  return media_router_idle_icon_;
+  switch (state_) {
+    case MEDIA_ROUTER_ACTION_IDLE:
+      return media_router_idle_icon_;
+    case MEDIA_ROUTER_ACTION_ACTIVE:
+      return media_router_active_icon_;
+    case MEDIA_ROUTER_ACTION_ERROR:
+      return media_router_error_icon_;
+    case MEDIA_ROUTER_ACTION_WARNING:
+      return media_router_warning_icon_;
+    default:
+      NOTREACHED();
+      return media_router_idle_icon_;
+  }
 }
 
 base::string16 MediaRouterAction::GetActionName() const {
   return name_;
 }
 
 base::string16 MediaRouterAction::GetAccessibleName(
     content::WebContents* web_contents) const {
   return GetTooltip(web_contents);
 }
@@ skipping 37 matching lines @@
 bool MediaRouterAction::ExecuteAction(bool by_user) {
   GetMediaRouterDialogController()->ShowMediaRouterDialog();
   if (platform_delegate_)
     platform_delegate_->CloseOverflowMenuIfOpen();
   return true;
 }
 
 void MediaRouterAction::UpdateState() {
 }
 
+bool MediaRouterAction::DisabledClickOpensMenu() const {
+  return false;
+}
+
+void MediaRouterAction::SetCurrentIssue(const media_router::Issue* issue) {
+  if (issue)
+    issue_.reset(new media_router::Issue(*issue));
+  else
+    issue_.reset();
+
+  MaybeUpdateIcon();
+}
+
+void MediaRouterAction::SetHasLocalRoutes(bool has_local_routes) {
+  has_local_routes_ = has_local_routes;
+  MaybeUpdateIcon();
+}
+
 MediaRouterDialogController*
 MediaRouterAction::GetMediaRouterDialogController() {
   DCHECK(delegate_);
   content::WebContents* web_contents = delegate_->GetCurrentWebContents();
   DCHECK(web_contents);
   return MediaRouterDialogController::GetOrCreateForWebContents(web_contents);
 }
 
-bool MediaRouterAction::DisabledClickOpensMenu() const {
-  return false;
+media_router::MediaRouter* MediaRouterAction::GetMediaRouter() {
+  DCHECK(delegate_);
+  content::WebContents* web_contents = delegate_->GetCurrentWebContents();
+  return web_contents ?
+      media_router::MediaRouterFactory::GetApiForBrowserContext(
+          web_contents->GetBrowserContext()) : nullptr;
 }
+
+void MediaRouterAction::MaybeUpdateIcon() {
+  MediaRouterActionState new_state = GetMediaRouterActionState();
+
+  // Update the current state if it has changed.
+  if (new_state != state_) {
+    state_ = new_state;
+
+    // Update the icon to reflect the new state.
+    if (delegate_)
+      delegate_->UpdateState();
+  }
+}
+
+MediaRouterActionState MediaRouterAction::GetMediaRouterActionState() {
+  // Highest priority is to indicate whether there's an issue.
+  if (issue_) {
+    if (issue_.get()->severity() == media_router::Issue::FATAL)
+      return MEDIA_ROUTER_ACTION_ERROR;
+    else if (issue_.get()->severity() == media_router::Issue::WARNING)
+      return MEDIA_ROUTER_ACTION_WARNING;
+  }
+
+  if (has_local_routes_)
+    return MEDIA_ROUTER_ACTION_ACTIVE;
+
+  return MEDIA_ROUTER_ACTION_IDLE;
+}