1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139
|
// 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 "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 "ui/gfx/image/image.h"
class Browser;
class ExtensionAction;
class ExtensionActionPlatformDelegate;
class GURL;
namespace extensions {
class Command;
class Extension;
class ExtensionRegistry;
}
// The platform-independent controller for an ExtensionAction that is shown on
// the toolbar (such as a page or browser action).
// Since this class doesn't own the extension or extension action in question,
// be sure to check for validity using ExtensionIsValid() before using those
// members (see also comments above ExtensionIsValid()).
class ExtensionActionViewController
: public ToolbarActionViewController,
public ExtensionActionIconFactory::Observer,
public ExtensionContextMenuModel::PopupDelegate {
public:
// The different options for showing a popup.
enum PopupShowAction { SHOW_POPUP, SHOW_POPUP_AND_INSPECT };
ExtensionActionViewController(const extensions::Extension* extension,
Browser* browser,
ExtensionAction* extension_action);
~ExtensionActionViewController() override;
// ToolbarActionViewController:
const std::string& GetId() const override;
void SetDelegate(ToolbarActionViewDelegate* delegate) override;
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;
gfx::NativeView GetPopupNativeView() override;
bool IsMenuRunning() const 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;
// 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_; }
Browser* browser() { return browser_; }
ExtensionAction* extension_action() { return extension_action_; }
const ExtensionAction* extension_action() const { return extension_action_; }
ToolbarActionViewDelegate* view_delegate() { return view_delegate_; }
void set_icon_observer(ExtensionActionIconFactory::Observer* icon_observer) {
icon_observer_ = icon_observer;
}
private:
// ExtensionActionIconFactory::Observer:
void OnIconUpdated() 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.
bool ExtensionIsValid() const;
// 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(PopupShowAction show_action, bool grant_tab_permissions);
// 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(PopupShowAction show_action,
const GURL& popup_url,
bool grant_tab_permissions);
// 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 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.
// 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_;
// An additional observer that we need to notify when the icon of the button
// has been updated.
ExtensionActionIconFactory::Observer* icon_observer_;
// The associated ExtensionRegistry; cached for quick checking.
extensions::ExtensionRegistry* extension_registry_;
DISALLOW_COPY_AND_ASSIGN(ExtensionActionViewController);
};
#endif // CHROME_BROWSER_UI_EXTENSIONS_EXTENSION_ACTION_VIEW_CONTROLLER_H_
|