Implement sidebar support for extension action popups

chrome/browser/ui/extensions/extension_action_view_controller.h

 // 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.
 
 #ifndef CHROME_BROWSER_UI_EXTENSIONS_EXTENSION_ACTION_VIEW_CONTROLLER_H_
 #define CHROME_BROWSER_UI_EXTENSIONS_EXTENSION_ACTION_VIEW_CONTROLLER_H_
 
 #include "base/memory/weak_ptr.h"
 #include "base/scoped_observer.h"
 #include "chrome/browser/extensions/extension_action_icon_factory.h"
 #include "chrome/browser/extensions/extension_context_menu_model.h"
+#include "chrome/browser/extensions/sidebar_container.h"
 #include "chrome/browser/ui/toolbar/toolbar_action_view_controller.h"
 #include "extensions/browser/extension_host_observer.h"
 #include "ui/gfx/image/image.h"
 
 class Browser;
 class ExtensionAction;
 class ExtensionActionPlatformDelegate;
 class GURL;
 class ToolbarActionsBar;
 
@@ skipping 30 matching lines @@
   gfx::Image GetIcon(content::WebContents* web_contents) override;
   gfx::ImageSkia GetIconWithBadge() override;
   base::string16 GetActionName() const override;
   base::string16 GetAccessibleName(content::WebContents* web_contents) const
       override;
   base::string16 GetTooltip(content::WebContents* web_contents) const override;
   bool IsEnabled(content::WebContents* web_contents) const override;
   bool WantsToRun(content::WebContents* web_contents) const override;
   bool HasPopup(content::WebContents* web_contents) const override;
   void HidePopup() override;
+  void HideSidebar() override;
   gfx::NativeView GetPopupNativeView() override;
   ui::MenuModel* GetContextMenu() override;
   void OnContextMenuClosed() override;
   bool CanDrag() const override;
   bool ExecuteAction(bool by_user) override;
   void UpdateState() override;
   void PaintExtra(gfx::Canvas* canvas,
                   const gfx::Rect& bounds,
                   content::WebContents* web_contents) const override;
   void RegisterCommand() override;
 
   // ExtensionContextMenuModel::PopupDelegate:
   void InspectPopup() override;
 
   // Closes the active popup (whether it was this action's popup or not).
   void HideActivePopup();
 
+  // Closes the active sidebar.
+  void HideActiveSidebar();
 
   // Populates |command| with the command associated with |extension|, if one
   // exists. Returns true if |command| was populated.
   bool GetExtensionCommand(extensions::Command* command);
 
   const extensions::Extension* extension() const { return extension_.get(); }
   Browser* browser() { return browser_; }
   ExtensionAction* extension_action() { return extension_action_; }
   const ExtensionAction* extension_action() const { return extension_action_; }
   ToolbarActionViewDelegate* view_delegate() { return view_delegate_; }
   bool is_showing_popup() const { return popup_host_ != nullptr; }
+  bool is_showing_sidebar() const { return sidebar_container_ != nullptr; }
 
   void set_icon_observer(ExtensionActionIconFactory::Observer* icon_observer) {
     icon_observer_ = icon_observer;
   }
 
  private:
+  // Update button state to be pressed
+  void PressButton(bool grant_tab_permissions);
+  void PressButtonWithSlideOutIfEnabled(const base::Closure& closure);
+
+  // Update button state to be unpressed
+  void RaiseButton();
+
   // ExtensionActionIconFactory::Observer:
   void OnIconUpdated() override;
 
   // ExtensionHostObserver:
   void OnExtensionHostDestroyed(const extensions::ExtensionHost* host) override;
 
   // Checks if the associated |extension| is still valid by checking its
   // status in the registry. Since the OnExtensionUnloaded() notifications are
   // not in a deterministic order, it's possible that the view tries to refresh
   // itself before we're notified to remove it.
@@ skipping 14 matching lines @@
   // associated |popup_url|. |grant_tab_permissions| is true if active tab
   // permissions should be given to the extension; this is only true if the
   // popup is opened through a user action.
   // The popup may not be shown synchronously if the extension is hidden and
   // first needs to slide itself out.
   // Returns true if a popup will be shown.
   bool TriggerPopupWithUrl(PopupShowAction show_action,
                            const GURL& popup_url,
                            bool grant_tab_permissions);
 
+  // Begins the process of showing the sidebar for the extension action,
+  // given the associated |popup_url|.
+  // The sidebar may not be shown synchronously if the extension is hidden and
+  // first needs to slide itself out.
+  // Returns true if a sidebar will be shown.
+  bool TriggerSidebarWithUrl(const GURL& popup_url);
+
   // Shows the popup with the given |host|.
   void ShowPopup(scoped_ptr<extensions::ExtensionViewHost> host,
                  bool grant_tab_permissions,
                  PopupShowAction show_action);
 
   // Handles cleanup after the popup closes.
   void OnPopupClosed();
 
   // The extension associated with the action we're displaying.
   scoped_refptr<const extensions::Extension> extension_;
 
   // The corresponding browser.
   Browser* browser_;
 
   // The browser action this view represents. The ExtensionAction is not owned
   // by this class.
   ExtensionAction* extension_action_;
 
   // The owning ToolbarActionsBar, if any. This will be null if this is a
   // page action without the toolbar redesign turned on.
   // TODO(devlin): Would this be better behind a delegate interface? On the one
   // hand, it's odd for this class to know about ToolbarActionsBar, but on the
   // other, yet-another-delegate-class might just confuse things.
   ToolbarActionsBar* toolbar_actions_bar_;
 
   // The extension popup's host if the popup is visible; null otherwise.
   extensions::ExtensionViewHost* popup_host_;
 
+  // The sidebar container if the sidebar is visible.
+  scoped_ptr<extensions::SidebarContainer> sidebar_container_;
+
   // The context menu model for the extension.
   scoped_refptr<ExtensionContextMenuModel> context_menu_model_;
 
   // Our view delegate.
   ToolbarActionViewDelegate* view_delegate_;
 
   // The delegate to handle platform-specific implementations.
   scoped_ptr<ExtensionActionPlatformDelegate> platform_delegate_;
 
   // The object that will be used to get the browser action icon for us.
@@ skipping 11 matching lines @@
 
   ScopedObserver<extensions::ExtensionHost, extensions::ExtensionHostObserver>
       popup_host_observer_;
 
   base::WeakPtrFactory<ExtensionActionViewController> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(ExtensionActionViewController);
 };
 
 #endif  // CHROME_BROWSER_UI_EXTENSIONS_EXTENSION_ACTION_VIEW_CONTROLLER_H_