[Extension Toolbar] Slide out overflowed actions for popups

chrome/browser/ui/extensions/extension_action_view_controller.cc

 // Copyright 2014 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/extensions/extension_action_view_controller.h"
 
 #include "base/logging.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/extensions/api/commands/command_service.h"
 #include "chrome/browser/extensions/api/extension_action/extension_action_api.h"
 #include "chrome/browser/extensions/extension_action.h"
 #include "chrome/browser/extensions/extension_view.h"
 #include "chrome/browser/extensions/extension_view_host.h"
+#include "chrome/browser/extensions/extension_view_host_factory.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/sessions/session_tab_helper.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/extensions/accelerator_priority.h"
 #include "chrome/browser/ui/extensions/extension_action_platform_delegate.h"
 #include "chrome/browser/ui/toolbar/toolbar_action_view_delegate.h"
 #include "chrome/browser/ui/toolbar/toolbar_actions_bar.h"
+#include "chrome/browser/ui/toolbar/toolbar_actions_bar.h"
 #include "chrome/common/extensions/api/extension_action/action_info.h"
 #include "extensions/browser/extension_host.h"
 #include "extensions/browser/extension_registry.h"
 #include "extensions/common/extension.h"
+#include "extensions/common/feature_switch.h"
 #include "extensions/common/manifest_constants.h"
 #include "ui/gfx/image/image_skia.h"
 #include "ui/gfx/image/image_skia_operations.h"
 
 using extensions::ActionInfo;
 using extensions::CommandService;
 
 ExtensionActionViewController::ExtensionActionViewController(
     const extensions::Extension* extension,
     Browser* browser,
     ExtensionAction* extension_action,
     ToolbarActionsBar* toolbar_actions_bar)
     : extension_(extension),
       browser_(browser),
       extension_action_(extension_action),
       toolbar_actions_bar_(toolbar_actions_bar),
       popup_host_(nullptr),
       view_delegate_(nullptr),
       platform_delegate_(ExtensionActionPlatformDelegate::Create(this)),
       icon_factory_(browser->profile(), extension, extension_action, this),
       icon_observer_(nullptr),
       extension_registry_(
           extensions::ExtensionRegistry::Get(browser_->profile())),
-      popup_host_observer_(this) {
+      popup_host_observer_(this),
+      weak_factory_(this) {
   DCHECK(extension_action);
   DCHECK(extension_action->action_type() == ActionInfo::TYPE_PAGE ||
          extension_action->action_type() == ActionInfo::TYPE_BROWSER);
   DCHECK(extension);
 }
 
 ExtensionActionViewController::~ExtensionActionViewController() {
   DCHECK(!is_showing_popup());
 }
 
@@ skipping 133 matching lines @@
   if (!ExtensionIsValid())
     return false;
 
   if (extensions::ExtensionActionAPI::Get(browser_->profile())
           ->ExecuteExtensionAction(
               extension_, browser_, grant_tab_permissions) ==
       ExtensionAction::ACTION_SHOW_POPUP) {
     GURL popup_url = extension_action_->GetPopupUrl(
         SessionTabHelper::IdForTab(view_delegate_->GetCurrentWebContents()));
     return GetPreferredPopupViewController()
-        ->ShowPopupWithUrl(show_action, popup_url, grant_tab_permissions);
+        ->TriggerPopupWithUrl(show_action, popup_url, grant_tab_permissions);
   }
   return false;
 }
 
 void ExtensionActionViewController::PaintExtra(
     gfx::Canvas* canvas,
     const gfx::Rect& bounds,
     content::WebContents* web_contents) const {
   if (!ExtensionIsValid())
     return;
@@ skipping 34 matching lines @@
   if (toolbar_actions_bar_) {
     toolbar_actions_bar_->HideActivePopup();
   } else {
     DCHECK_EQ(ActionInfo::TYPE_PAGE, extension_action_->action_type());
     // In the traditional toolbar, page actions only know how to close their own
     // popups.
     HidePopup();
   }
 }
 
+void ExtensionActionViewController::OnMenuClosed() {
+  if (toolbar_actions_bar_->popped_out_action() == this &&
+      !is_showing_popup())
+    toolbar_actions_bar_->PopInAction();
+}
+
 bool ExtensionActionViewController::GetExtensionCommand(
     extensions::Command* command) {
   DCHECK(command);
   if (!ExtensionIsValid())
     return false;
 
   CommandService* command_service = CommandService::Get(browser_->profile());
   if (extension_action_->action_type() == ActionInfo::TYPE_PAGE) {
     return command_service->GetPageActionCommand(
         extension_->id(), CommandService::ACTIVE, command, NULL);
   }
   return command_service->GetBrowserActionCommand(
       extension_->id(), CommandService::ACTIVE, command, NULL);
 }
 
 ExtensionActionViewController*
 ExtensionActionViewController::GetPreferredPopupViewController() {
   if (toolbar_actions_bar_ && toolbar_actions_bar_->in_overflow_mode()) {
     return static_cast<ExtensionActionViewController*>(
         toolbar_actions_bar_->GetMainControllerForAction(this));
   }
 
   return this;
 }
 
-bool ExtensionActionViewController::ShowPopupWithUrl(
+bool ExtensionActionViewController::TriggerPopupWithUrl(
     PopupShowAction show_action,
     const GURL& popup_url,
     bool grant_tab_permissions) {
   if (!ExtensionIsValid())
     return false;
 
   bool already_showing = is_showing_popup();
 
   // Always hide the current popup, even if it's not owned by this extension.
   // Only one popup should be visible at a time.
   HideActivePopup();
 
   // If we were showing a popup already, then we treat the action to open the
   // same one as a desire to close it (like clicking a menu button that was
   // already open).
   if (already_showing)
     return false;
 
-  popup_host_ = platform_delegate_->ShowPopupWithUrl(
-      show_action, popup_url, grant_tab_permissions);
-  if (popup_host_) {
-    popup_host_observer_.Add(popup_host_);
-    if (toolbar_actions_bar_)
-      toolbar_actions_bar_->SetPopupOwner(this);
-    view_delegate_->OnPopupShown(grant_tab_permissions);
+  scoped_ptr<extensions::ExtensionViewHost> host(
+      extensions::ExtensionViewHostFactory::CreatePopupHost(popup_url,
+                                                            browser_));
+  if (!host)
+    return false;
+
+  popup_host_ = host.get();
+  popup_host_observer_.Add(popup_host_);
+  if (toolbar_actions_bar_)
+    toolbar_actions_bar_->SetPopupOwner(this);
+
+  if (toolbar_actions_bar_ &&
+      !toolbar_actions_bar_->IsActionVisible(this) &&
+      extensions::FeatureSwitch::extension_action_redesign()->IsEnabled()) {
+    platform_delegate_->CloseOverflowMenu();
+    toolbar_actions_bar_->PopOutAction(
+        this,
+        base::Bind(&ExtensionActionViewController::ShowPopup,
+                   weak_factory_.GetWeakPtr(),
+                   base::Passed(host.Pass()),
+                   grant_tab_permissions,
+                   show_action));
+  } else {
+    ShowPopup(host.Pass(), grant_tab_permissions, show_action);
   }
-  return is_showing_popup();
+
+  return true;
+}
+
+void ExtensionActionViewController::ShowPopup(
+    scoped_ptr<extensions::ExtensionViewHost> popup_host,
+    bool grant_tab_permissions,
+    PopupShowAction show_action) {
+  // It's possible that the popup should be closed before it finishes opening
+  // (since it can open asynchronously). Check before proceeding.
+  if (!popup_host_)
+    return;
+  platform_delegate_->ShowPopup(
+      popup_host.Pass(), grant_tab_permissions, show_action);
+  view_delegate_->OnPopupShown(grant_tab_permissions);
 }
 
 void ExtensionActionViewController::OnPopupClosed() {
   popup_host_observer_.Remove(popup_host_);
   popup_host_ = nullptr;
-  if (toolbar_actions_bar_)
+  if (toolbar_actions_bar_) {
     toolbar_actions_bar_->SetPopupOwner(nullptr);
+    if (toolbar_actions_bar_->popped_out_action() == this &&
+        !platform_delegate_->IsMenuRunning())
+      toolbar_actions_bar_->PopInAction();
+  }
   view_delegate_->OnPopupClosed();
 }