src/chrome/browser/extensions/api/extension_action/extension_action_api.h

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #ifndef CHROME_BROWSER_EXTENSIONS_API_EXTENSION_ACTION_EXTENSION_ACTION_API_H_
   6 #define CHROME_BROWSER_EXTENSIONS_API_EXTENSION_ACTION_EXTENSION_ACTION_API_H_
   7
   8 #include <string>
   9
  10 #include "base/memory/weak_ptr.h"
  11 #include "chrome/browser/extensions/api/profile_keyed_api_factory.h"
  12 #include "chrome/browser/extensions/chrome_extension_function.h"
  13 #include "chrome/browser/extensions/extension_action.h"
  14 #include "content/public/browser/notification_observer.h"
  15 #include "content/public/browser/notification_registrar.h"
  16
  17 namespace base {
  18 class DictionaryValue;
  19 }
  20
  21 namespace content {
  22 class WebContents;
  23 }
  24
  25 namespace extensions {
  26 class ExtensionPrefs;
  27 class TabHelper;
  28
  29 class ExtensionActionAPI : public ProfileKeyedAPI {
  30  public:
  31   explicit ExtensionActionAPI(Profile* profile);
  32   virtual ~ExtensionActionAPI();
  33
  34   // Convenience method to get the instance for a profile.
  35   static ExtensionActionAPI* Get(Profile* profile);
  36
  37   static bool GetBrowserActionVisibility(const ExtensionPrefs* prefs,
  38                                          const std::string& extension_id);
  39   static void SetBrowserActionVisibility(ExtensionPrefs* prefs,
  40                                          const std::string& extension_id,
  41                                          bool visible);
  42
  43   // Fires the onClicked event for page_action.
  44   static void PageActionExecuted(Profile* profile,
  45                                  const ExtensionAction& page_action,
  46                                  int tab_id,
  47                                  const std::string& url,
  48                                  int button);
  49
  50   // Fires the onClicked event for script_badge.
  51   static void ScriptBadgeExecuted(Profile* profile,
  52                                   const ExtensionAction& script_badge,
  53                                   int tab_id);
  54
  55   // Fires the onClicked event for browser_action.
  56   static void BrowserActionExecuted(Profile* profile,
  57                                     const ExtensionAction& browser_action,
  58                                     content::WebContents* web_contents);
  59
  60   // ProfileKeyedAPI implementation.
  61   static ProfileKeyedAPIFactory<ExtensionActionAPI>* GetFactoryInstance();
  62
  63  private:
  64   friend class ProfileKeyedAPIFactory<ExtensionActionAPI>;
  65
  66   // The DispatchEvent methods forward events to the |profile|'s event router.
  67   static void DispatchEventToExtension(Profile* profile,
  68                                        const std::string& extension_id,
  69                                        const std::string& event_name,
  70                                        scoped_ptr<base::ListValue> event_args);
  71
  72   // Called to dispatch a deprecated style page action click event that was
  73   // registered like:
  74   //   chrome.pageActions["name"].addListener(function(actionId, info){})
  75   static void DispatchOldPageActionEvent(Profile* profile,
  76     const std::string& extension_id,
  77     const std::string& page_action_id,
  78     int tab_id,
  79     const std::string& url,
  80     int button);
  81
  82   // Called when either a browser or page action is executed. Figures out which
  83   // event to send based on what the extension wants.
  84   static void ExtensionActionExecuted(Profile* profile,
  85                                       const ExtensionAction& extension_action,
  86                                       content::WebContents* web_contents);
  87
  88   // ProfileKeyedAPI implementation.
  89   static const char* service_name() { return "ExtensionActionAPI"; }
  90
  91   DISALLOW_COPY_AND_ASSIGN(ExtensionActionAPI);
  92 };
  93
  94 // This class manages reading and writing browser action values from storage.
  95 class ExtensionActionStorageManager
  96     : public content::NotificationObserver,
  97       public base::SupportsWeakPtr<ExtensionActionStorageManager> {
  98  public:
  99   explicit ExtensionActionStorageManager(Profile* profile);
 100   virtual ~ExtensionActionStorageManager();
 101
 102  private:
 103   // NotificationObserver:
 104   virtual void Observe(int type,
 105                        const content::NotificationSource& source,
 106                        const content::NotificationDetails& details) OVERRIDE;
 107
 108   // Reads/Writes the ExtensionAction's default values to/from storage.
 109   void WriteToStorage(ExtensionAction* extension_action);
 110   void ReadFromStorage(
 111       const std::string& extension_id, scoped_ptr<base::Value> value);
 112
 113   Profile* profile_;
 114   content::NotificationRegistrar registrar_;
 115 };
 116
 117 // Implementation of the browserAction, pageAction, and scriptBadge APIs.
 118 //
 119 // Divergent behaviour between the three is minimal (pageAction and scriptBadge
 120 // have required tabIds while browserAction's are optional, they have different
 121 // internal browser notification requirements, and not all functions are defined
 122 // for all APIs).
 123 class ExtensionActionFunction : public ChromeSyncExtensionFunction {
 124  public:
 125   static bool ParseCSSColorString(const std::string& color_string,
 126                                   SkColor* result);
 127
 128  protected:
 129   ExtensionActionFunction();
 130   virtual ~ExtensionActionFunction();
 131   virtual bool RunImpl() OVERRIDE;
 132   virtual bool RunExtensionAction() = 0;
 133
 134   bool ExtractDataFromArguments();
 135   void NotifyChange();
 136   void NotifyBrowserActionChange();
 137   void NotifyLocationBarChange();
 138   void NotifySystemIndicatorChange();
 139   bool SetVisible(bool visible);
 140
 141   // Extension-related information for |tab_id_|.
 142   // CHECK-fails if there is no tab.
 143   extensions::TabHelper& tab_helper() const;
 144
 145   // All the extension action APIs take a single argument called details that
 146   // is a dictionary.
 147   base::DictionaryValue* details_;
 148
 149   // The tab id the extension action function should apply to, if any, or
 150   // kDefaultTabId if none was specified.
 151   int tab_id_;
 152
 153   // WebContents for |tab_id_| if one exists.
 154   content::WebContents* contents_;
 155
 156   // The extension action for the current extension.
 157   ExtensionAction* extension_action_;
 158 };
 159
 160 //
 161 // Implementations of each extension action API.
 162 //
 163 // pageAction and browserAction bindings are created for these by extending them
 164 // then declaring an EXTENSION_FUNCTION_NAME.
 165 //
 166
 167 // show
 168 class ExtensionActionShowFunction : public ExtensionActionFunction {
 169  protected:
 170   virtual ~ExtensionActionShowFunction() {}
 171   virtual bool RunExtensionAction() OVERRIDE;
 172 };
 173
 174 // hide
 175 class ExtensionActionHideFunction : public ExtensionActionFunction {
 176  protected:
 177   virtual ~ExtensionActionHideFunction() {}
 178   virtual bool RunExtensionAction() OVERRIDE;
 179 };
 180
 181 // setIcon
 182 class ExtensionActionSetIconFunction : public ExtensionActionFunction {
 183  protected:
 184   virtual ~ExtensionActionSetIconFunction() {}
 185   virtual bool RunExtensionAction() OVERRIDE;
 186 };
 187
 188 // setTitle
 189 class ExtensionActionSetTitleFunction : public ExtensionActionFunction {
 190  protected:
 191   virtual ~ExtensionActionSetTitleFunction() {}
 192   virtual bool RunExtensionAction() OVERRIDE;
 193 };
 194
 195 // setPopup
 196 class ExtensionActionSetPopupFunction : public ExtensionActionFunction {
 197  protected:
 198   virtual ~ExtensionActionSetPopupFunction() {}
 199   virtual bool RunExtensionAction() OVERRIDE;
 200 };
 201
 202 // setBadgeText
 203 class ExtensionActionSetBadgeTextFunction : public ExtensionActionFunction {
 204  protected:
 205   virtual ~ExtensionActionSetBadgeTextFunction() {}
 206   virtual bool RunExtensionAction() OVERRIDE;
 207 };
 208
 209 // setBadgeBackgroundColor
 210 class ExtensionActionSetBadgeBackgroundColorFunction
 211     : public ExtensionActionFunction {
 212  protected:
 213   virtual ~ExtensionActionSetBadgeBackgroundColorFunction() {}
 214   virtual bool RunExtensionAction() OVERRIDE;
 215 };
 216
 217 // getTitle
 218 class ExtensionActionGetTitleFunction : public ExtensionActionFunction {
 219  protected:
 220   virtual ~ExtensionActionGetTitleFunction() {}
 221   virtual bool RunExtensionAction() OVERRIDE;
 222 };
 223
 224 // getPopup
 225 class ExtensionActionGetPopupFunction : public ExtensionActionFunction {
 226  protected:
 227   virtual ~ExtensionActionGetPopupFunction() {}
 228   virtual bool RunExtensionAction() OVERRIDE;
 229 };
 230
 231 // getBadgeText
 232 class ExtensionActionGetBadgeTextFunction : public ExtensionActionFunction {
 233  protected:
 234   virtual ~ExtensionActionGetBadgeTextFunction() {}
 235   virtual bool RunExtensionAction() OVERRIDE;
 236 };
 237
 238 // getBadgeBackgroundColor
 239 class ExtensionActionGetBadgeBackgroundColorFunction
 240     : public ExtensionActionFunction {
 241  protected:
 242   virtual ~ExtensionActionGetBadgeBackgroundColorFunction() {}
 243   virtual bool RunExtensionAction() OVERRIDE;
 244 };
 245
 246 //
 247 // browserAction.* aliases for supported browserAction APIs.
 248 //
 249
 250 class BrowserActionSetIconFunction : public ExtensionActionSetIconFunction {
 251  public:
 252   DECLARE_EXTENSION_FUNCTION("browserAction.setIcon", BROWSERACTION_SETICON)
 253
 254  protected:
 255   virtual ~BrowserActionSetIconFunction() {}
 256 };
 257
 258 class BrowserActionSetTitleFunction : public ExtensionActionSetTitleFunction {
 259  public:
 260   DECLARE_EXTENSION_FUNCTION("browserAction.setTitle", BROWSERACTION_SETTITLE)
 261
 262  protected:
 263   virtual ~BrowserActionSetTitleFunction() {}
 264 };
 265
 266 class BrowserActionSetPopupFunction : public ExtensionActionSetPopupFunction {
 267  public:
 268   DECLARE_EXTENSION_FUNCTION("browserAction.setPopup", BROWSERACTION_SETPOPUP)
 269
 270  protected:
 271   virtual ~BrowserActionSetPopupFunction() {}
 272 };
 273
 274 class BrowserActionGetTitleFunction : public ExtensionActionGetTitleFunction {
 275  public:
 276   DECLARE_EXTENSION_FUNCTION("browserAction.getTitle", BROWSERACTION_GETTITLE)
 277
 278  protected:
 279   virtual ~BrowserActionGetTitleFunction() {}
 280 };
 281
 282 class BrowserActionGetPopupFunction : public ExtensionActionGetPopupFunction {
 283  public:
 284   DECLARE_EXTENSION_FUNCTION("browserAction.getPopup", BROWSERACTION_GETPOPUP)
 285
 286  protected:
 287   virtual ~BrowserActionGetPopupFunction() {}
 288 };
 289
 290 class BrowserActionSetBadgeTextFunction
 291     : public ExtensionActionSetBadgeTextFunction {
 292  public:
 293   DECLARE_EXTENSION_FUNCTION("browserAction.setBadgeText",
 294                              BROWSERACTION_SETBADGETEXT)
 295
 296  protected:
 297   virtual ~BrowserActionSetBadgeTextFunction() {}
 298 };
 299
 300 class BrowserActionSetBadgeBackgroundColorFunction
 301     : public ExtensionActionSetBadgeBackgroundColorFunction {
 302  public:
 303   DECLARE_EXTENSION_FUNCTION("browserAction.setBadgeBackgroundColor",
 304                              BROWSERACTION_SETBADGEBACKGROUNDCOLOR)
 305
 306  protected:
 307   virtual ~BrowserActionSetBadgeBackgroundColorFunction() {}
 308 };
 309
 310 class BrowserActionGetBadgeTextFunction
 311     : public ExtensionActionGetBadgeTextFunction {
 312  public:
 313   DECLARE_EXTENSION_FUNCTION("browserAction.getBadgeText",
 314                              BROWSERACTION_GETBADGETEXT)
 315
 316  protected:
 317   virtual ~BrowserActionGetBadgeTextFunction() {}
 318 };
 319
 320 class BrowserActionGetBadgeBackgroundColorFunction
 321     : public ExtensionActionGetBadgeBackgroundColorFunction {
 322  public:
 323   DECLARE_EXTENSION_FUNCTION("browserAction.getBadgeBackgroundColor",
 324                              BROWSERACTION_GETBADGEBACKGROUNDCOLOR)
 325
 326  protected:
 327   virtual ~BrowserActionGetBadgeBackgroundColorFunction() {}
 328 };
 329
 330 class BrowserActionEnableFunction : public ExtensionActionShowFunction {
 331  public:
 332   DECLARE_EXTENSION_FUNCTION("browserAction.enable", BROWSERACTION_ENABLE)
 333
 334  protected:
 335   virtual ~BrowserActionEnableFunction() {}
 336 };
 337
 338 class BrowserActionDisableFunction : public ExtensionActionHideFunction {
 339  public:
 340   DECLARE_EXTENSION_FUNCTION("browserAction.disable", BROWSERACTION_DISABLE)
 341
 342  protected:
 343   virtual ~BrowserActionDisableFunction() {}
 344 };
 345
 346 class BrowserActionOpenPopupFunction : public ChromeAsyncExtensionFunction,
 347                                        public content::NotificationObserver {
 348  public:
 349   DECLARE_EXTENSION_FUNCTION("browserAction.openPopup",
 350                              BROWSERACTION_OPEN_POPUP)
 351   BrowserActionOpenPopupFunction();
 352
 353  private:
 354   virtual ~BrowserActionOpenPopupFunction() {}
 355
 356   // ExtensionFunction:
 357   virtual bool RunImpl() OVERRIDE;
 358
 359   virtual void Observe(int type,
 360                        const content::NotificationSource& source,
 361                        const content::NotificationDetails& details) OVERRIDE;
 362   void OpenPopupTimedOut();
 363
 364   content::NotificationRegistrar registrar_;
 365   bool response_sent_;
 366
 367   DISALLOW_COPY_AND_ASSIGN(BrowserActionOpenPopupFunction);
 368 };
 369
 370 //
 371 // scriptBadge.* aliases for supported scriptBadge APIs.
 372 //
 373
 374 class ScriptBadgeSetPopupFunction : public ExtensionActionSetPopupFunction {
 375  public:
 376   DECLARE_EXTENSION_FUNCTION("scriptBadge.setPopup", SCRIPTBADGE_SETPOPUP)
 377
 378  protected:
 379   virtual ~ScriptBadgeSetPopupFunction() {}
 380 };
 381
 382 class ScriptBadgeGetPopupFunction : public ExtensionActionGetPopupFunction {
 383  public:
 384   DECLARE_EXTENSION_FUNCTION("scriptBadge.getPopup", SCRIPTBADGE_GETPOPUP)
 385
 386  protected:
 387   virtual ~ScriptBadgeGetPopupFunction() {}
 388 };
 389
 390 // scriptBadge.getAttention(tabId)
 391 class ScriptBadgeGetAttentionFunction : public ExtensionActionFunction {
 392  public:
 393   DECLARE_EXTENSION_FUNCTION("scriptBadge.getAttention",
 394                              SCRIPTBADGE_GETATTENTION)
 395
 396   virtual bool RunExtensionAction() OVERRIDE;
 397
 398  protected:
 399   virtual ~ScriptBadgeGetAttentionFunction();
 400 };
 401
 402 }  // namespace extensions
 403
 404 //
 405 // pageAction.* aliases for supported pageAction APIs.
 406 //
 407
 408 class PageActionShowFunction : public extensions::ExtensionActionShowFunction {
 409  public:
 410   DECLARE_EXTENSION_FUNCTION("pageAction.show", PAGEACTION_SHOW)
 411
 412  protected:
 413   virtual ~PageActionShowFunction() {}
 414 };
 415
 416 class PageActionHideFunction : public extensions::ExtensionActionHideFunction {
 417  public:
 418   DECLARE_EXTENSION_FUNCTION("pageAction.hide", PAGEACTION_HIDE)
 419
 420  protected:
 421   virtual ~PageActionHideFunction() {}
 422 };
 423
 424 class PageActionSetIconFunction
 425     : public extensions::ExtensionActionSetIconFunction {
 426  public:
 427   DECLARE_EXTENSION_FUNCTION("pageAction.setIcon", PAGEACTION_SETICON)
 428
 429  protected:
 430   virtual ~PageActionSetIconFunction() {}
 431 };
 432
 433 class PageActionSetTitleFunction
 434     : public extensions::ExtensionActionSetTitleFunction {
 435  public:
 436   DECLARE_EXTENSION_FUNCTION("pageAction.setTitle", PAGEACTION_SETTITLE)
 437
 438  protected:
 439   virtual ~PageActionSetTitleFunction() {}
 440 };
 441
 442 class PageActionSetPopupFunction
 443     : public extensions::ExtensionActionSetPopupFunction {
 444  public:
 445   DECLARE_EXTENSION_FUNCTION("pageAction.setPopup", PAGEACTION_SETPOPUP)
 446
 447  protected:
 448   virtual ~PageActionSetPopupFunction() {}
 449 };
 450
 451 class PageActionGetTitleFunction
 452     : public extensions::ExtensionActionGetTitleFunction {
 453  public:
 454   DECLARE_EXTENSION_FUNCTION("pageAction.getTitle", PAGEACTION_GETTITLE)
 455
 456  protected:
 457   virtual ~PageActionGetTitleFunction() {}
 458 };
 459
 460 class PageActionGetPopupFunction
 461     : public extensions::ExtensionActionGetPopupFunction {
 462  public:
 463   DECLARE_EXTENSION_FUNCTION("pageAction.getPopup", PAGEACTION_GETPOPUP)
 464
 465  protected:
 466   virtual ~PageActionGetPopupFunction() {}
 467 };
 468
 469 // Base class for deprecated page actions APIs
 470 class PageActionsFunction : public ChromeSyncExtensionFunction {
 471  protected:
 472   PageActionsFunction();
 473   virtual ~PageActionsFunction();
 474   bool SetPageActionEnabled(bool enable);
 475 };
 476
 477 // Implement chrome.pageActions.enableForTab().
 478 class EnablePageActionsFunction : public PageActionsFunction {
 479  public:
 480   DECLARE_EXTENSION_FUNCTION("pageActions.enableForTab",
 481                              PAGEACTIONS_ENABLEFORTAB)
 482
 483  protected:
 484   virtual ~EnablePageActionsFunction() {}
 485
 486   // ExtensionFunction:
 487   virtual bool RunImpl() OVERRIDE;
 488 };
 489
 490 // Implement chrome.pageActions.disableForTab().
 491 class DisablePageActionsFunction : public PageActionsFunction {
 492  public:
 493   DECLARE_EXTENSION_FUNCTION("pageActions.disableForTab",
 494                              PAGEACTIONS_DISABLEFORTAB)
 495
 496  protected:
 497   virtual ~DisablePageActionsFunction() {}
 498
 499   // ExtensionFunction:
 500   virtual bool RunImpl() OVERRIDE;
 501 };
 502
 503 #endif  // CHROME_BROWSER_EXTENSIONS_API_EXTENSION_ACTION_EXTENSION_ACTION_API_H_