Home | History | Annotate | Download | only in tabs 
      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_TABS_TABS_API_H_
      6 #define CHROME_BROWSER_EXTENSIONS_API_TABS_TABS_API_H_
      7 
      8 #include <string>
      9 #include <vector>
     10 
     11 #include "base/compiler_specific.h"
     12 #include "chrome/browser/extensions/api/capture_web_contents_function.h"
     13 #include "chrome/browser/extensions/api/execute_code_function.h"
     14 #include "chrome/browser/extensions/chrome_extension_function.h"
     15 #include "chrome/common/extensions/api/tabs.h"
     16 #include "content/public/browser/notification_observer.h"
     17 #include "content/public/browser/notification_registrar.h"
     18 #include "extensions/common/extension_resource.h"
     19 #include "extensions/common/user_script.h"
     20 #include "url/gurl.h"
     21 
     22 class GURL;
     23 class SkBitmap;
     24 class TabStripModel;
     25 
     26 namespace base {
     27 class DictionaryValue;
     28 }
     29 
     30 namespace content {
     31 class WebContents;
     32 }
     33 
     34 namespace ui {
     35 class ListSelectionModel;
     36 }
     37 
     38 namespace user_prefs {
     39 class PrefRegistrySyncable;
     40 }
     41 
     42 namespace extensions {
     43 
     44 // Windows
     45 class WindowsGetFunction : public ChromeSyncExtensionFunction {
     46   virtual ~WindowsGetFunction() {}
     47   virtual bool RunSync() OVERRIDE;
     48   DECLARE_EXTENSION_FUNCTION("windows.get", WINDOWS_GET)
     49 };
     50 class WindowsGetCurrentFunction : public ChromeSyncExtensionFunction {
     51   virtual ~WindowsGetCurrentFunction() {}
     52   virtual bool RunSync() OVERRIDE;
     53   DECLARE_EXTENSION_FUNCTION("windows.getCurrent", WINDOWS_GETCURRENT)
     54 };
     55 class WindowsGetLastFocusedFunction : public ChromeSyncExtensionFunction {
     56   virtual ~WindowsGetLastFocusedFunction() {}
     57   virtual bool RunSync() OVERRIDE;
     58   DECLARE_EXTENSION_FUNCTION("windows.getLastFocused", WINDOWS_GETLASTFOCUSED)
     59 };
     60 class WindowsGetAllFunction : public ChromeSyncExtensionFunction {
     61   virtual ~WindowsGetAllFunction() {}
     62   virtual bool RunSync() OVERRIDE;
     63   DECLARE_EXTENSION_FUNCTION("windows.getAll", WINDOWS_GETALL)
     64 };
     65 class WindowsCreateFunction : public ChromeSyncExtensionFunction {
     66   virtual ~WindowsCreateFunction() {}
     67   virtual bool RunSync() OVERRIDE;
     68   // Returns whether the window should be created in incognito mode.
     69   // |create_data| are the options passed by the extension. It may be NULL.
     70   // |urls| is the list of urls to open. If we are creating an incognito window,
     71   // the function will remove these urls which may not be opened in incognito
     72   // mode.  If window creation leads the browser into an erroneous state,
     73   // |is_error| is set to true (also, error_ member variable is assigned
     74   // the proper error message).
     75   bool ShouldOpenIncognitoWindow(
     76       const api::windows::Create::Params::CreateData* create_data,
     77       std::vector<GURL>* urls,
     78       bool* is_error);
     79   DECLARE_EXTENSION_FUNCTION("windows.create", WINDOWS_CREATE)
     80 };
     81 class WindowsUpdateFunction : public ChromeSyncExtensionFunction {
     82   virtual ~WindowsUpdateFunction() {}
     83   virtual bool RunSync() OVERRIDE;
     84   DECLARE_EXTENSION_FUNCTION("windows.update", WINDOWS_UPDATE)
     85 };
     86 class WindowsRemoveFunction : public ChromeSyncExtensionFunction {
     87   virtual ~WindowsRemoveFunction() {}
     88   virtual bool RunSync() OVERRIDE;
     89   DECLARE_EXTENSION_FUNCTION("windows.remove", WINDOWS_REMOVE)
     90 };
     91 
     92 // Tabs
     93 class TabsGetFunction : public ChromeSyncExtensionFunction {
     94   virtual ~TabsGetFunction() {}
     95   virtual bool RunSync() OVERRIDE;
     96   DECLARE_EXTENSION_FUNCTION("tabs.get", TABS_GET)
     97 };
     98 class TabsGetCurrentFunction : public ChromeSyncExtensionFunction {
     99   virtual ~TabsGetCurrentFunction() {}
    100   virtual bool RunSync() OVERRIDE;
    101   DECLARE_EXTENSION_FUNCTION("tabs.getCurrent", TABS_GETCURRENT)
    102 };
    103 class TabsGetSelectedFunction : public ChromeSyncExtensionFunction {
    104   virtual ~TabsGetSelectedFunction() {}
    105   virtual bool RunSync() OVERRIDE;
    106   DECLARE_EXTENSION_FUNCTION("tabs.getSelected", TABS_GETSELECTED)
    107 };
    108 class TabsGetAllInWindowFunction : public ChromeSyncExtensionFunction {
    109   virtual ~TabsGetAllInWindowFunction() {}
    110   virtual bool RunSync() OVERRIDE;
    111   DECLARE_EXTENSION_FUNCTION("tabs.getAllInWindow", TABS_GETALLINWINDOW)
    112 };
    113 class TabsQueryFunction : public ChromeSyncExtensionFunction {
    114   virtual ~TabsQueryFunction() {}
    115   virtual bool RunSync() OVERRIDE;
    116   DECLARE_EXTENSION_FUNCTION("tabs.query", TABS_QUERY)
    117 };
    118 class TabsCreateFunction : public ChromeSyncExtensionFunction {
    119   virtual ~TabsCreateFunction() {}
    120   virtual bool RunSync() OVERRIDE;
    121   DECLARE_EXTENSION_FUNCTION("tabs.create", TABS_CREATE)
    122 };
    123 class TabsDuplicateFunction : public ChromeSyncExtensionFunction {
    124   virtual ~TabsDuplicateFunction() {}
    125   virtual bool RunSync() OVERRIDE;
    126   DECLARE_EXTENSION_FUNCTION("tabs.duplicate", TABS_DUPLICATE)
    127 };
    128 class TabsHighlightFunction : public ChromeSyncExtensionFunction {
    129   virtual ~TabsHighlightFunction() {}
    130   virtual bool RunSync() OVERRIDE;
    131   bool HighlightTab(TabStripModel* tabstrip,
    132                     ui::ListSelectionModel* selection,
    133                     int *active_index,
    134                     int index);
    135   DECLARE_EXTENSION_FUNCTION("tabs.highlight", TABS_HIGHLIGHT)
    136 };
    137 class TabsUpdateFunction : public ChromeAsyncExtensionFunction {
    138  public:
    139   TabsUpdateFunction();
    140 
    141  protected:
    142   virtual ~TabsUpdateFunction() {}
    143   virtual bool UpdateURL(const std::string& url,
    144                          int tab_id,
    145                          bool* is_async);
    146   virtual void PopulateResult();
    147 
    148   content::WebContents* web_contents_;
    149 
    150  private:
    151   virtual bool RunAsync() OVERRIDE;
    152   void OnExecuteCodeFinished(const std::string& error,
    153                              int32 on_page_id,
    154                              const GURL& on_url,
    155                              const base::ListValue& script_result);
    156 
    157   DECLARE_EXTENSION_FUNCTION("tabs.update", TABS_UPDATE)
    158 };
    159 class TabsMoveFunction : public ChromeSyncExtensionFunction {
    160   virtual ~TabsMoveFunction() {}
    161   virtual bool RunSync() OVERRIDE;
    162   bool MoveTab(int tab_id,
    163                int* new_index,
    164                int iteration,
    165                base::ListValue* tab_values,
    166                int* window_id);
    167   DECLARE_EXTENSION_FUNCTION("tabs.move", TABS_MOVE)
    168 };
    169 class TabsReloadFunction : public ChromeSyncExtensionFunction {
    170   virtual ~TabsReloadFunction() {}
    171   virtual bool RunSync() OVERRIDE;
    172   DECLARE_EXTENSION_FUNCTION("tabs.reload", TABS_RELOAD)
    173 };
    174 class TabsRemoveFunction : public ChromeSyncExtensionFunction {
    175   virtual ~TabsRemoveFunction() {}
    176   virtual bool RunSync() OVERRIDE;
    177   bool RemoveTab(int tab_id);
    178   DECLARE_EXTENSION_FUNCTION("tabs.remove", TABS_REMOVE)
    179 };
    180 class TabsDetectLanguageFunction : public ChromeAsyncExtensionFunction,
    181                                    public content::NotificationObserver {
    182  private:
    183   virtual ~TabsDetectLanguageFunction() {}
    184   virtual bool RunAsync() OVERRIDE;
    185 
    186   virtual void Observe(int type,
    187                        const content::NotificationSource& source,
    188                        const content::NotificationDetails& details) OVERRIDE;
    189   void GotLanguage(const std::string& language);
    190   content::NotificationRegistrar registrar_;
    191   DECLARE_EXTENSION_FUNCTION("tabs.detectLanguage", TABS_DETECTLANGUAGE)
    192 };
    193 class TabsCaptureVisibleTabFunction
    194     : public extensions::CaptureWebContentsFunction {
    195  public:
    196   static void RegisterProfilePrefs(user_prefs::PrefRegistrySyncable* registry);
    197 
    198  protected:
    199   virtual ~TabsCaptureVisibleTabFunction() {}
    200 
    201  private:
    202   // extensions::CaptureWebContentsFunction:
    203   virtual bool IsScreenshotEnabled() OVERRIDE;
    204   virtual content::WebContents* GetWebContentsForID(int id) OVERRIDE;
    205   virtual void OnCaptureFailure(FailureReason reason) OVERRIDE;
    206 
    207   DECLARE_EXTENSION_FUNCTION("tabs.captureVisibleTab", TABS_CAPTUREVISIBLETAB)
    208 };
    209 
    210 // Implement API call tabs.executeScript and tabs.insertCSS.
    211 class ExecuteCodeInTabFunction : public ExecuteCodeFunction {
    212  public:
    213   ExecuteCodeInTabFunction();
    214 
    215  protected:
    216   virtual ~ExecuteCodeInTabFunction();
    217 
    218   // ExtensionFunction:
    219   virtual bool HasPermission() OVERRIDE;
    220 
    221   // Initialize the |execute_tab_id_| and |details_| if they haven't already
    222   // been. Returns whether initialization was successful.
    223   virtual bool Init() OVERRIDE;
    224   virtual bool CanExecuteScriptOnPage() OVERRIDE;
    225   virtual ScriptExecutor* GetScriptExecutor() OVERRIDE;
    226   virtual bool IsWebView() const OVERRIDE;
    227   virtual const GURL& GetWebViewSrc() const OVERRIDE;
    228 
    229  private:
    230   // Id of tab which executes code.
    231   int execute_tab_id_;
    232 };
    233 
    234 class TabsExecuteScriptFunction : public ExecuteCodeInTabFunction {
    235  protected:
    236   virtual bool ShouldInsertCSS() const OVERRIDE;
    237 
    238  private:
    239   virtual ~TabsExecuteScriptFunction() {}
    240 
    241   virtual void OnExecuteCodeFinished(
    242       const std::string& error,
    243       int32 on_page_id,
    244       const GURL& on_url,
    245       const base::ListValue& script_result) OVERRIDE;
    246 
    247   DECLARE_EXTENSION_FUNCTION("tabs.executeScript", TABS_EXECUTESCRIPT)
    248 };
    249 
    250 class TabsInsertCSSFunction : public ExecuteCodeInTabFunction {
    251  private:
    252   virtual ~TabsInsertCSSFunction() {}
    253 
    254   virtual bool ShouldInsertCSS() const OVERRIDE;
    255 
    256   DECLARE_EXTENSION_FUNCTION("tabs.insertCSS", TABS_INSERTCSS)
    257 };
    258 
    259 }  // namespace extensions
    260 
    261 #endif  // CHROME_BROWSER_EXTENSIONS_API_TABS_TABS_API_H_
    262