Implement sidebar support for extension action 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/tabs/tab_strip_model.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 "chrome/common/icon_with_badge_image_source.h"
+#include "chrome/common/pref_names.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;
@@ skipping 30 matching lines @@
   return extension_->id();
 }
 
 void ExtensionActionViewController::SetDelegate(
     ToolbarActionViewDelegate* delegate) {
   DCHECK((delegate == nullptr) ^ (view_delegate_ == nullptr));
   if (delegate) {
     view_delegate_ = delegate;
     platform_delegate_->OnDelegateSet();
   } else {
-    if (is_showing_popup())
+    if (popup_host_)
       HidePopup();
     platform_delegate_.reset();
     view_delegate_ = nullptr;
   }
 }
 
 gfx::Image ExtensionActionViewController::GetIcon(
     content::WebContents* web_contents,
     const gfx::Size& size) {
   if (!ExtensionIsValid())
@@ skipping 45 matching lines @@
 bool ExtensionActionViewController::HasPopup(
     content::WebContents* web_contents) const {
   if (!ExtensionIsValid())
     return false;
 
   int tab_id = SessionTabHelper::IdForTab(web_contents);
   return (tab_id < 0) ? false : extension_action_->HasPopup(tab_id);
 }
 
 void ExtensionActionViewController::HidePopup() {
-  if (is_showing_popup()) {
-    popup_host_->Close();
-    // We need to do these actions synchronously (instead of closing and then
-    // performing the rest of the cleanup in OnExtensionHostDestroyed()) because
-    // the extension host may close asynchronously, and we need to keep the view
-    // delegate up-to-date.
-    if (popup_host_)
-      OnPopupClosed();
-  }
+  if (!is_showing_popup())
+    return;
+
+  popup_host_->Close();
+  // We need to do these actions synchronously (instead of closing and then
+  // performing the rest of the cleanup in OnExtensionHostDestroyed()) because
+  // the extension host may close asynchronously, and we need to keep the view
+  // delegate up-to-date.
+  if (popup_host_)
+    OnPopupClosed();
 }
 
 gfx::NativeView ExtensionActionViewController::GetPopupNativeView() {
   return popup_host_ ? popup_host_->view()->GetNativeView() : nullptr;
 }
 
 ui::MenuModel* ExtensionActionViewController::GetContextMenu() {
   if (!ExtensionIsValid() || !extension()->ShowConfigureContextMenus())
     return nullptr;
 
@@ skipping 35 matching lines @@
                                                   bool grant_tab_permissions) {
   if (!ExtensionIsValid())
     return false;
 
   if (extensions::ExtensionActionAPI::Get(browser_->profile())
           ->ExecuteExtensionAction(
               extension_.get(), browser_, grant_tab_permissions) ==
       ExtensionAction::ACTION_SHOW_POPUP) {
     GURL popup_url = extension_action_->GetPopupUrl(
         SessionTabHelper::IdForTab(view_delegate_->GetCurrentWebContents()));
-    return GetPreferredPopupViewController()
-        ->TriggerPopupWithUrl(show_action, popup_url, grant_tab_permissions);
+
+    if (extension_action_->open_in_sidebar())
+      return GetPreferredPopupViewController()->TriggerSidebarWithUrl(
+          popup_url);
+    else
+      return GetPreferredPopupViewController()->TriggerPopupWithUrl(
+          show_action, popup_url, grant_tab_permissions);
   }
   return false;
 }
 
 void ExtensionActionViewController::RegisterCommand() {
   if (!ExtensionIsValid())
     return;
 
   platform_delegate_->RegisterCommand();
 }
@@ skipping 64 matching lines @@
         toolbar_actions_bar_->GetMainControllerForAction(this));
   }
 
   return this;
 }
 
 bool ExtensionActionViewController::TriggerPopupWithUrl(
     PopupShowAction show_action,
     const GURL& popup_url,
     bool grant_tab_permissions) {
-  if (!ExtensionIsValid())
+
+  // 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 (is_showing_popup()) {
+    HideActivePopup();
     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;
-
   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_->IsActionVisibleOnMainBar(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);
-  }
+  PressButtonWithSlideOutIfEnabled(base::Bind(
+      &ExtensionActionViewController::ShowPopup, weak_factory_.GetWeakPtr(),
+      base::Passed(host.Pass()), grant_tab_permissions, show_action));
 
   return true;
 }
 
+bool ExtensionActionViewController::TriggerSidebarWithUrl(
+    const GURL& sidebar_url) {
+  // Sidebar is only allowed via browser action
+  if (ActionInfo::TYPE_BROWSER != extension_action_->action_type())
+    return false;
+
+  DCHECK(toolbar_actions_bar_);
+
+  if (sidebar_host_) {
+    HideActiveSidebar();
+    return false;
+  }
+
+  HideActiveSidebar();
+
+  sidebar_host_.reset(extensions::ExtensionViewHostFactory::CreateSidebarHost(
+      sidebar_url, browser_));
+
+  sidebar_host_->CreateRenderViewSoon();
+  sidebar_host_->host_contents()->SetInitialFocus();
+
+  DCHECK(toolbar_actions_bar_);
+  toolbar_actions_bar_->SetSidebarOwner(this);
+
+  PressButtonWithSlideOutIfEnabled(
+      base::Bind(&ExtensionActionViewController::PressButton,
+                 weak_factory_.GetWeakPtr(), true));
+  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);
+  PressButton(grant_tab_permissions);
 }
 
 void ExtensionActionViewController::OnPopupClosed() {
-  popup_host_observer_.Remove(popup_host_);
-  popup_host_ = nullptr;
+  if (popup_host_) {
+    popup_host_observer_.Remove(popup_host_);
+    popup_host_ = nullptr;
+  }
+  if (toolbar_actions_bar_)
+    toolbar_actions_bar_->SetPopupOwner(nullptr);
+
+  RaiseButton();
+}
+
+void ExtensionActionViewController::HideActiveSidebar() {
+  DCHECK(toolbar_actions_bar_);
+  DCHECK_EQ(ActionInfo::TYPE_BROWSER, extension_action_->action_type());
+  toolbar_actions_bar_->HideActiveSidebar();
+}
+
+void ExtensionActionViewController::HideSidebar() {
+  if (!sidebar_host_)
+    return;
+
+  sidebar_host_.reset();
+  if (toolbar_actions_bar_)
+    toolbar_actions_bar_->SetSidebarOwner(nullptr);
+
+  RaiseButton();
+}
+
+void ExtensionActionViewController::RaiseButton() {
+  // Reset button state
   if (toolbar_actions_bar_) {
-    toolbar_actions_bar_->SetPopupOwner(nullptr);
     if (toolbar_actions_bar_->popped_out_action() == this &&
-        !view_delegate_->IsMenuRunning())
+        !view_delegate_->IsMenuRunning()) {
       toolbar_actions_bar_->UndoPopOut();
+    }
   }
   view_delegate_->OnPopupClosed();
 }
 
+void ExtensionActionViewController::PressButtonWithSlideOutIfEnabled(
+    const base::Closure& closure) {
+  if (!toolbar_actions_bar_ ||
+      toolbar_actions_bar_->IsActionVisibleOnMainBar(this) ||
+      !extensions::FeatureSwitch::extension_action_redesign()->IsEnabled()) {
+    closure.Run();
+    return;
+  }
+
+  // We disabled PopOutAction for sidebar
+  if (extension_action_->open_in_sidebar()) {
+    closure.Run();
+    return;
+  }
+
+  platform_delegate_->CloseOverflowMenu();
+  toolbar_actions_bar_->PopOutAction(this, closure);
+}
+
+void ExtensionActionViewController::PressButton(bool grant_tab_permissions) {
+  view_delegate_->OnPopupShown(grant_tab_permissions);
+}
+
 scoped_ptr<IconWithBadgeImageSource>
 ExtensionActionViewController::GetIconImageSource(
     content::WebContents* web_contents,
     const gfx::Size& size) {
   int tab_id = SessionTabHelper::IdForTab(web_contents);
   scoped_ptr<IconWithBadgeImageSource> image_source(
       new IconWithBadgeImageSource(size));
   image_source->SetIcon(icon_factory_.GetIcon(tab_id));
   scoped_ptr<IconWithBadgeImageSource::Badge> badge;
   std::string badge_text = extension_action_->GetBadgeText(tab_id);
@@ skipping 15 matching lines @@
     // overflowed, we add a decoration so that the user can see which overflowed
     // action wants to run (since they wouldn't be able to see the change from
     // grayscale to color).
     bool is_overflow =
         toolbar_actions_bar_ && toolbar_actions_bar_->in_overflow_mode();
     image_source->set_paint_decoration(WantsToRun(web_contents) && is_overflow);
   }
 
   return image_source.Pass();
 }