Show the Cast toolbar icon ephemerally when Cast is in use

chrome/browser/ui/webui/media_router/media_router_dialog_controller_impl.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/webui/media_router/media_router_dialog_controller_impl.h"
 
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "base/macros.h"
 #include "base/trace_event/trace_event.h"
 #include "build/build_config.h"
 #include "chrome/browser/media/router/presentation_service_delegate_impl.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/browser_finder.h"
 #include "chrome/browser/ui/browser_window.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.h"
 #include "chrome/browser/ui/webui/constrained_web_dialog_ui.h"
 #include "chrome/browser/ui/webui/media_router/media_router_ui.h"
 #include "chrome/common/url_constants.h"
 #include "components/guest_view/browser/guest_view_base.h"
 #include "components/web_modal/web_contents_modal_dialog_host.h"
 #include "content/public/browser/navigation_controller.h"
 #include "content/public/browser/navigation_details.h"
 #include "content/public/browser/navigation_entry.h"
 #include "content/public/browser/render_frame_host.h"
@@ skipping 17 matching lines @@
 namespace {
 
 constexpr const int kMaxHeight = 2000;
 constexpr const int kMinHeight = 80;
 constexpr const int kWidth = 340;
 
 // WebDialogDelegate that specifies what the Media Router dialog
 // will look like.
 class MediaRouterDialogDelegate : public WebDialogDelegate {
  public:
-  MediaRouterDialogDelegate(base::WeakPtr<MediaRouterAction> action,
+  explicit MediaRouterDialogDelegate(
       const base::WeakPtr<MediaRouterDialogControllerImpl>& controller)
-      : action_(action),
-        controller_(controller) {}
+      : controller_(controller) {}
   ~MediaRouterDialogDelegate() override {}
 
   // WebDialogDelegate implementation.
   ui::ModalType GetDialogModalType() const override {
     // Not used, returning dummy value.
     return ui::MODAL_TYPE_WINDOW;
   }
 
   base::string16 GetDialogTitle() const override {
     return base::string16();
   }
 
   GURL GetDialogContentURL() const override {
     return GURL(chrome::kChromeUIMediaRouterURL);
   }
 
   void GetWebUIMessageHandlers(
       std::vector<WebUIMessageHandler*>* handlers) const override {
     // MediaRouterUI adds its own message handlers.
   }
 
-  void GetDialogSize(gfx::Size* size) const override;
+  void GetDialogSize(gfx::Size* size) const override {
+    DCHECK(size);
+    // GetDialogSize() is called when the browser window resizes. We may want to
+    // update the maximum height of the dialog and scale the WebUI to the new
+    // height. |size| is not set because the dialog is auto-resizeable.
+    controller_->UpdateMaxDialogSize();
+  }
 
   std::string GetDialogArgs() const override {
     return std::string();
   }
 
-  void OnDialogClosed(const std::string& json_retval) override {
-    // We don't delete |this| here because this class is owned
-    // by ConstrainedWebDialogDelegate.
-    if (action_)
-      action_->OnPopupHidden();
-  }
-
   void OnCloseContents(WebContents* source, bool* out_close_dialog) override {
     if (out_close_dialog)
       *out_close_dialog = true;
   }
 
   bool ShouldShowDialogTitle() const override {
     return false;
   }
 
  private:
-  base::WeakPtr<MediaRouterAction> action_;
   base::WeakPtr<MediaRouterDialogControllerImpl> controller_;
 
   DISALLOW_COPY_AND_ASSIGN(MediaRouterDialogDelegate);
 };
 
-void MediaRouterDialogDelegate::GetDialogSize(gfx::Size* size) const {
-  DCHECK(size);
-  // GetDialogSize() is called when the browser window resizes. We may want to
-  // update the maximum height of the dialog and scale the WebUI to the new
-  // height. |size| is not set because the dialog is auto-resizeable.
-  controller_->UpdateMaxDialogSize();
-}
-
 }  // namespace
 
 // static
 MediaRouterDialogControllerImpl*
 MediaRouterDialogControllerImpl::GetOrCreateForWebContents(
     WebContents* web_contents) {
   DCHECK(web_contents);
   // This call does nothing if the controller already exists.
   MediaRouterDialogControllerImpl::CreateForWebContents(web_contents);
   return MediaRouterDialogControllerImpl::FromWebContents(web_contents);
@@ skipping 26 matching lines @@
     dialog_controller_->CloseMediaRouterDialog();
   }
 
   MediaRouterDialogControllerImpl* const dialog_controller_;
 };
 
 MediaRouterDialogControllerImpl::MediaRouterDialogControllerImpl(
     WebContents* web_contents)
     : MediaRouterDialogController(web_contents),
       media_router_dialog_pending_(false),
+      tab_strip_model_observer_(this),
       weak_ptr_factory_(this) {
+  tab_strip_model_observer_.Add(
+      chrome::FindBrowserWithWebContents(initiator())->tab_strip_model());
 }
 
 MediaRouterDialogControllerImpl::~MediaRouterDialogControllerImpl() {
 }
 
 WebContents* MediaRouterDialogControllerImpl::GetMediaRouterDialog() const {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   return dialog_observer_.get() ? dialog_observer_->web_contents() : nullptr;
 }
 
 void MediaRouterDialogControllerImpl::SetMediaRouterAction(
     const base::WeakPtr<MediaRouterAction>& action) {
-  if (!action_)
-    action_ = action;
-}
-
-bool MediaRouterDialogControllerImpl::IsShowingMediaRouterDialog() const {
-  return GetMediaRouterDialog() != nullptr;
+  action_ = action;
 }
 
 void MediaRouterDialogControllerImpl::UpdateMaxDialogSize() {
   WebContents* media_router_dialog = GetMediaRouterDialog();
   if (!media_router_dialog)
     return;
 
   content::WebUI* web_ui = media_router_dialog->GetWebUI();
   if (web_ui) {
     MediaRouterUI* media_router_ui =
         static_cast<MediaRouterUI*>(web_ui->GetController());
     if (media_router_ui) {
       Browser* browser = chrome::FindBrowserWithWebContents(initiator());
       web_modal::WebContentsModalDialogHost* host = nullptr;
       if (browser)
         host = browser->window()->GetWebContentsModalDialogHost();
 
       gfx::Size maxSize = host ?
           host->GetMaximumDialogSize() :
           initiator()->GetContainerBounds().size();
 
       // The max height of the dialog should be 90% of the browser window
       // height. The width stays fixed.
       maxSize.Enlarge(0, -0.1 * maxSize.height());
       media_router_ui->UpdateMaxDialogHeight(maxSize.height());
     }
   }
 }
 
+bool MediaRouterDialogControllerImpl::IsShowingMediaRouterDialog() const {
+  return GetMediaRouterDialog() != nullptr;
+}
+
+bool MediaRouterDialogControllerImpl::ShowMediaRouterDialog() {
+  if (!action_)
+    ShowMediaRouterAction();
+  return MediaRouterDialogController::ShowMediaRouterDialog();
+}
+
+void MediaRouterDialogControllerImpl::ActiveTabChanged(
+    content::WebContents* old_contents,
+    content::WebContents* new_contents,
+    int index,
+    int reason) {
+  if (IsShowingMediaRouterDialog() && !action_)
+    ShowMediaRouterAction();
+}
+
 void MediaRouterDialogControllerImpl::CloseMediaRouterDialog() {
   WebContents* media_router_dialog = GetMediaRouterDialog();
   if (!media_router_dialog)
     return;
 
   content::WebUI* web_ui = media_router_dialog->GetWebUI();
   if (web_ui) {
     MediaRouterUI* media_router_ui =
         static_cast<MediaRouterUI*>(web_ui->GetController());
     if (media_router_ui)
       media_router_ui->Close();
   }
 }
 
 void MediaRouterDialogControllerImpl::CreateMediaRouterDialog() {
   DCHECK(!dialog_observer_.get());
 
   base::Time dialog_creation_time = base::Time::Now();
   TRACE_EVENT_NESTABLE_ASYNC_BEGIN0("media_router", "UI", initiator());
 
   Profile* profile =
       Profile::FromBrowserContext(initiator()->GetBrowserContext());
   DCHECK(profile);
 
   // |web_dialog_delegate|'s owner is |constrained_delegate|.
   // |constrained_delegate| is owned by the parent |views::View|.
   WebDialogDelegate* web_dialog_delegate =
-      new MediaRouterDialogDelegate(action_, weak_ptr_factory_.GetWeakPtr());
+      new MediaRouterDialogDelegate(weak_ptr_factory_.GetWeakPtr());
 
   // |ShowConstrainedWebDialogWithAutoResize()| will end up creating
   // ConstrainedWebDialogDelegateViewViews containing a WebContents containing
   // the MediaRouterUI, using the provided |web_dialog_delegate|. Then, the
   // view is shown as a modal dialog constrained to the |initiator| WebContents.
   // The dialog will resize between the given minimum and maximum size bounds
   // based on the currently rendered contents.
   ConstrainedWebDialogDelegate* constrained_delegate =
       ShowConstrainedWebDialogWithAutoResize(
           profile, web_dialog_delegate, initiator(),
@@ skipping 10 matching lines @@
     MediaRouterUI* media_router_ui = static_cast<MediaRouterUI*>(
         media_router_dialog->GetWebUI()->GetController());
     DCHECK(media_router_ui);
     media_router_ui->SetUIInitializationTimer(dialog_creation_time);
   }
 
   media_router_dialog_pending_ = true;
 
   dialog_observer_.reset(new DialogWebContentsObserver(
       media_router_dialog, this));
-
-  if (action_)
-    action_->OnPopupShown();
 }
 
 void MediaRouterDialogControllerImpl::Reset() {
   MediaRouterDialogController::Reset();
   dialog_observer_.reset();
+  if (action_)
+    action_->OnPopupHidden();
 }
 
 void MediaRouterDialogControllerImpl::OnDialogNavigated(
     const content::LoadCommittedDetails& details) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   WebContents* media_router_dialog = GetMediaRouterDialog();
   CHECK(media_router_dialog);
   ui::PageTransition transition_type = details.entry->GetTransitionType();
   content::NavigationType nav_type = details.type;
 
   // New |media_router_dialog| is created.
   DCHECK(media_router_dialog_pending_);
   DCHECK(ui::PageTransitionCoreTypeIs(transition_type,
                                       ui::PAGE_TRANSITION_AUTO_TOPLEVEL) &&
       nav_type == content::NAVIGATION_TYPE_NEW_PAGE)
       << "transition_type: " << transition_type << ", "
       << "nav_type: " << nav_type;
 
   media_router_dialog_pending_ = false;
 
   PopulateDialog(media_router_dialog);
+
+  if (action_)
+    action_->OnPopupShown();
 }
 
 void MediaRouterDialogControllerImpl::PopulateDialog(
     content::WebContents* media_router_dialog) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   DCHECK(media_router_dialog);
   if (!initiator() || !media_router_dialog->GetWebUI()) {
     Reset();
     return;
   }
@@ skipping 10 matching lines @@
       PresentationServiceDelegateImpl::GetOrCreateForWebContents(initiator())
           ->GetWeakPtr();
   if (!create_connection_request.get()) {
     media_router_ui->InitWithDefaultMediaSource(delegate);
   } else {
     media_router_ui->InitWithPresentationSessionRequest(
         initiator(), delegate, std::move(create_connection_request));
   }
 }
 
+void MediaRouterDialogControllerImpl::ShowMediaRouterAction() {
+  Profile* profile =
+      Profile::FromBrowserContext(initiator()->GetBrowserContext());
+  if (!profile)
+    return;
+
+  ToolbarActionsModel* model = ToolbarActionsModel::Get(profile);
+  if (model &&
+      !model->HasComponentAction(
+          ComponentToolbarActionsFactory::kMediaRouterActionId)) {
+    model->AddComponentAction(
+        ComponentToolbarActionsFactory::kMediaRouterActionId);
+  }
+}
+
 }  // namespace media_router