chrome/browser/ui/views/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_VIEWS_EXTENSIONS_EXTENSION_ACTION_VIEW_CONTROLLER_H_
#define CHROME_BROWSER_UI_VIEWS_EXTENSIONS_EXTENSION_ACTION_VIEW_CONTROLLER_H_

#include "chrome/browser/extensions/extension_action_icon_factory.h"
#include "chrome/browser/extensions/extension_context_menu_model.h"
#include "chrome/browser/ui/toolbar/toolbar_action_view_controller.h"
#include "chrome/browser/ui/views/extensions/extension_popup.h"
#include "content/public/browser/notification_observer.h"
#include "content/public/browser/notification_registrar.h"
#include "ui/base/accelerators/accelerator.h"
#include "ui/gfx/image/image.h"
#include "ui/views/context_menu_controller.h"
#include "ui/views/widget/widget_observer.h"

class Browser;
class ExtensionAction;
class ToolbarActionViewDelegate;

namespace content {
class WebContents;
}

namespace extensions {
class Command;
class Extension;
}

namespace ui {
class Accelerator;
}

namespace views {
class MenuRunner;
class View;
class Widget;
}

// An abstract "View" for an ExtensionAction (either a BrowserAction or a
// PageAction). This contains the logic for showing the action's popup and
// the context menu. This class doesn't subclass View directly, as the
// implementations for page actions/browser actions are different types of
// views.
// All common logic for executing extension actions should go in this class;
// ToolbarActionViewDelegate classes should only have knowledge relating to
// the views::View wrapper.
class ExtensionActionViewController
    : public ToolbarActionViewController,
      public content::NotificationObserver,
      public ExtensionActionIconFactory::Observer,
      public ExtensionContextMenuModel::PopupDelegate,
      public ui::AcceleratorTarget,
      public views::ContextMenuController,
      public views::WidgetObserver {
 public:
  ExtensionActionViewController(const extensions::Extension* extension,
                                Browser* browser,
                                ExtensionAction* extension_action);
  virtual ~ExtensionActionViewController();

  // ToolbarActionViewController:
  virtual const std::string& GetId() const override;
  virtual void SetDelegate(ToolbarActionViewDelegate* delegate) override;
  virtual gfx::Image GetIcon(content::WebContents* web_contents) override;
  virtual gfx::ImageSkia GetIconWithBadge() override;
  virtual base::string16 GetAccessibleName(content::WebContents* web_contents)
      const override;
  virtual base::string16 GetTooltip(content::WebContents* web_contents)
      const override;
  virtual bool IsEnabled(content::WebContents* web_contents) const override;
  virtual bool HasPopup(content::WebContents* web_contents) const override;
  virtual void HidePopup() override;
  virtual gfx::NativeView GetPopupNativeView() override;
  virtual bool IsMenuRunning() const override;
  virtual bool CanDrag() const override;
  virtual bool ExecuteAction(bool by_user) override;
  virtual void PaintExtra(gfx::Canvas* canvas,
                          const gfx::Rect& bounds,
                          content::WebContents* web_contents) const override;
  virtual void RegisterCommand() override;

  // ExtensionContextMenuModel::PopupDelegate:
  virtual void InspectPopup() override;

  // Executes the extension action with |show_action|. If
  // |grant_tab_permissions| is true, this will grant the extension active tab
  // permissions. Only do this if this was done through a user action (and not
  // e.g. an API). Returns true if a popup is shown.
  bool ExecuteAction(ExtensionPopup::ShowAction show_action,
                     bool grant_tab_permissions);

  void set_icon_observer(ExtensionActionIconFactory::Observer* icon_observer) {
    icon_observer_ = icon_observer;
  }

  const extensions::Extension* extension() const { return extension_; }
  Browser* browser() { return browser_; }
  ExtensionAction* extension_action() { return extension_action_; }
  const ExtensionAction* extension_action() const { return extension_action_; }
  ExtensionPopup* popup() { return popup_; }

 private:
  // ExtensionActionIconFactory::Observer:
  virtual void OnIconUpdated() override;

  // ui::AcceleratorTarget:
  virtual bool AcceleratorPressed(const ui::Accelerator& accelerator) override;
  virtual bool CanHandleAccelerators() const override;

  // views::WidgetObserver:
  virtual void OnWidgetDestroying(views::Widget* widget) override;

  // views::ContextMenuController:
  virtual void ShowContextMenuForView(views::View* source,
                                      const gfx::Point& point,
                                      ui::MenuSourceType source_type) override;

  // content::NotificationObserver:
  virtual void Observe(int type,
                       const content::NotificationSource& source,
                       const content::NotificationDetails& details) override;

  // Shows the context menu for extension action.
  void DoShowContextMenu(ui::MenuSourceType source_type);

  // Shows the popup for the extension action, given the 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.
  // Returns true if a popup is successfully shown.
  bool ShowPopupWithUrl(ExtensionPopup::ShowAction show_action,
                        const GURL& popup_url,
                        bool grant_tab_permissions);

  // Populates |command| with the command associated with |extension|, if one
  // exists. Returns true if |command| was populated.
  bool GetExtensionCommand(extensions::Command* command);

  // Unregisters the accelerator for the extension action's command, if one
  // exists. If |only_if_removed| is true, then this will only unregister if the
  // command has been removed.
  void UnregisterCommand(bool only_if_removed);

  // Closes the currently-active menu, if needed. This is the case when there
  // is an active menu that wouldn't close automatically when a new one is
  // opened.
  // Returns true if a menu was closed, false otherwise.
  bool CloseActiveMenuIfNeeded();

  // Cleans up after the popup. If |close_widget| is true, this will call
  // Widget::Close() on the popup's widget; otherwise it assumes the popup is
  // already closing.
  void CleanupPopup(bool close_widget);

  // The extension associated with the action we're displaying.
  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_;

  // Our delegate.
  ToolbarActionViewDelegate* delegate_;

  // The object that will be used to get the browser action icon for us.
  // It may load the icon asynchronously (in which case the initial icon
  // returned by the factory will be transparent), so we have to observe it for
  // updates to the icon.
  ExtensionActionIconFactory icon_factory_;

  // The observer that we need to notify when the icon of the button has been
  // updated.
  ExtensionActionIconFactory::Observer* icon_observer_;

  // Responsible for running the menu.
  scoped_ptr<views::MenuRunner> menu_runner_;

  // The browser action's popup, if it is visible; NULL otherwise.
  ExtensionPopup* popup_;

  // The extension key binding accelerator this extension action is listening
  // for (to show the popup).
  scoped_ptr<ui::Accelerator> action_keybinding_;

  content::NotificationRegistrar registrar_;

  // If non-NULL, this is the next ExtensionActionViewController context menu
  // which wants to run once the current owner (this one) is done.
  base::Closure followup_context_menu_task_;

  base::WeakPtrFactory<ExtensionActionViewController> weak_factory_;

  DISALLOW_COPY_AND_ASSIGN(ExtensionActionViewController);
};

#endif  // CHROME_BROWSER_UI_VIEWS_EXTENSIONS_EXTENSION_ACTION_VIEW_CONTROLLER_H_