Home | History | Annotate | Download | only in developer_private 
      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_DEVELOPER_PRIVATE_DEVELOPER_PRIVATE_API_H_
      6 #define CHROME_BROWSER_EXTENSIONS_API_DEVELOPER_PRIVATE_DEVELOPER_PRIVATE_API_H_
      7 
      8 #include <set>
      9 
     10 #include "base/files/file.h"
     11 #include "base/scoped_observer.h"
     12 #include "chrome/browser/extensions/api/developer_private/entry_picker.h"
     13 #include "chrome/browser/extensions/api/file_system/file_system_api.h"
     14 #include "chrome/browser/extensions/chrome_extension_function.h"
     15 #include "chrome/browser/extensions/error_console/error_console.h"
     16 #include "chrome/browser/extensions/extension_install_prompt.h"
     17 #include "chrome/browser/extensions/extension_uninstall_dialog.h"
     18 #include "chrome/browser/extensions/pack_extension_job.h"
     19 #include "chrome/browser/extensions/requirements_checker.h"
     20 #include "content/public/browser/notification_observer.h"
     21 #include "content/public/browser/notification_registrar.h"
     22 #include "content/public/browser/render_view_host.h"
     23 #include "extensions/browser/browser_context_keyed_api_factory.h"
     24 #include "extensions/browser/event_router.h"
     25 #include "extensions/browser/extension_registry_observer.h"
     26 #include "storage/browser/fileapi/file_system_context.h"
     27 #include "storage/browser/fileapi/file_system_operation.h"
     28 #include "ui/shell_dialogs/select_file_dialog.h"
     29 
     30 class Profile;
     31 
     32 namespace extensions {
     33 
     34 class ExtensionError;
     35 class ExtensionRegistry;
     36 class ExtensionSystem;
     37 class ManagementPolicy;
     38 
     39 namespace api {
     40 
     41 class EntryPicker;
     42 class EntryPickerClient;
     43 
     44 namespace developer_private {
     45 
     46 struct ItemInfo;
     47 struct ItemInspectView;
     48 struct ProjectInfo;
     49 
     50 }  // namespace developer_private
     51 
     52 }  // namespace api
     53 
     54 namespace developer = api::developer_private;
     55 
     56 typedef std::vector<linked_ptr<developer::ItemInfo> > ItemInfoList;
     57 typedef std::vector<linked_ptr<developer::ProjectInfo> > ProjectInfoList;
     58 typedef std::vector<linked_ptr<developer::ItemInspectView> >
     59     ItemInspectViewList;
     60 
     61 class DeveloperPrivateEventRouter : public content::NotificationObserver,
     62                                     public ExtensionRegistryObserver,
     63                                     public ErrorConsole::Observer {
     64  public:
     65   explicit DeveloperPrivateEventRouter(Profile* profile);
     66   virtual ~DeveloperPrivateEventRouter();
     67 
     68   // Add or remove an ID to the list of extensions subscribed to events.
     69   void AddExtensionId(const std::string& extension_id);
     70   void RemoveExtensionId(const std::string& extension_id);
     71 
     72  private:
     73   // content::NotificationObserver implementation.
     74   virtual void Observe(int type,
     75                        const content::NotificationSource& source,
     76                        const content::NotificationDetails& details) OVERRIDE;
     77 
     78   // ExtensionRegistryObserver implementation.
     79   virtual void OnExtensionLoaded(content::BrowserContext* browser_context,
     80                                  const Extension* extension) OVERRIDE;
     81   virtual void OnExtensionUnloaded(
     82       content::BrowserContext* browser_context,
     83       const Extension* extension,
     84       UnloadedExtensionInfo::Reason reason) OVERRIDE;
     85   virtual void OnExtensionWillBeInstalled(
     86       content::BrowserContext* browser_context,
     87       const Extension* extension,
     88       bool is_update,
     89       bool from_ephemeral,
     90       const std::string& old_name) OVERRIDE;
     91   virtual void OnExtensionUninstalled(
     92       content::BrowserContext* browser_context,
     93       const Extension* extension,
     94       extensions::UninstallReason reason) OVERRIDE;
     95 
     96   // ErrorConsole::Observer implementation.
     97   virtual void OnErrorAdded(const ExtensionError* error) OVERRIDE;
     98 
     99   content::NotificationRegistrar registrar_;
    100 
    101   ScopedObserver<extensions::ExtensionRegistry,
    102                  extensions::ExtensionRegistryObserver>
    103       extension_registry_observer_;
    104 
    105   Profile* profile_;
    106 
    107   // The set of IDs of the Extensions that have subscribed to DeveloperPrivate
    108   // events. Since the only consumer of the DeveloperPrivate API is currently
    109   // the Apps Developer Tool (which replaces the chrome://extensions page), we
    110   // don't want to send information about the subscribing extension in an
    111   // update. In particular, we want to avoid entering a loop, which could happen
    112   // when, e.g., the Apps Developer Tool throws an error.
    113   std::set<std::string> extension_ids_;
    114 
    115   DISALLOW_COPY_AND_ASSIGN(DeveloperPrivateEventRouter);
    116 };
    117 
    118 // The profile-keyed service that manages the DeveloperPrivate API.
    119 class DeveloperPrivateAPI : public BrowserContextKeyedAPI,
    120                             public EventRouter::Observer {
    121  public:
    122   static BrowserContextKeyedAPIFactory<DeveloperPrivateAPI>*
    123       GetFactoryInstance();
    124 
    125   // Convenience method to get the DeveloperPrivateAPI for a profile.
    126   static DeveloperPrivateAPI* Get(content::BrowserContext* context);
    127 
    128   explicit DeveloperPrivateAPI(content::BrowserContext* context);
    129   virtual ~DeveloperPrivateAPI();
    130 
    131   void SetLastUnpackedDirectory(const base::FilePath& path);
    132 
    133   base::FilePath& GetLastUnpackedDirectory() {
    134     return last_unpacked_directory_;
    135   }
    136 
    137   // KeyedService implementation
    138   virtual void Shutdown() OVERRIDE;
    139 
    140   // EventRouter::Observer implementation.
    141   virtual void OnListenerAdded(const EventListenerInfo& details) OVERRIDE;
    142   virtual void OnListenerRemoved(const EventListenerInfo& details) OVERRIDE;
    143 
    144  private:
    145   friend class BrowserContextKeyedAPIFactory<DeveloperPrivateAPI>;
    146 
    147   // BrowserContextKeyedAPI implementation.
    148   static const char* service_name() { return "DeveloperPrivateAPI"; }
    149   static const bool kServiceRedirectedInIncognito = true;
    150   static const bool kServiceIsNULLWhileTesting = true;
    151 
    152   void RegisterNotifications();
    153 
    154   Profile* profile_;
    155 
    156   // Used to start the load |load_extension_dialog_| in the last directory that
    157   // was loaded.
    158   base::FilePath last_unpacked_directory_;
    159 
    160   // Created lazily upon OnListenerAdded.
    161   scoped_ptr<DeveloperPrivateEventRouter> developer_private_event_router_;
    162 
    163   DISALLOW_COPY_AND_ASSIGN(DeveloperPrivateAPI);
    164 };
    165 
    166 namespace api {
    167 
    168 class DeveloperPrivateAutoUpdateFunction : public ChromeSyncExtensionFunction {
    169  public:
    170   DECLARE_EXTENSION_FUNCTION("developerPrivate.autoUpdate",
    171                              DEVELOPERPRIVATE_AUTOUPDATE)
    172 
    173  protected:
    174   virtual ~DeveloperPrivateAutoUpdateFunction();
    175 
    176   // ExtensionFunction:
    177   virtual bool RunSync() OVERRIDE;
    178 };
    179 
    180 class DeveloperPrivateGetItemsInfoFunction
    181     : public ChromeAsyncExtensionFunction {
    182  public:
    183   DECLARE_EXTENSION_FUNCTION("developerPrivate.getItemsInfo",
    184                              DEVELOPERPRIVATE_GETITEMSINFO)
    185 
    186  protected:
    187   virtual ~DeveloperPrivateGetItemsInfoFunction();
    188 
    189   // ExtensionFunction:
    190   virtual bool RunAsync() OVERRIDE;
    191 
    192  private:
    193   scoped_ptr<developer::ItemInfo> CreateItemInfo(const Extension& item,
    194                                                  bool item_is_enabled);
    195 
    196   void GetIconsOnFileThread(
    197       ItemInfoList item_list,
    198       std::map<std::string, ExtensionResource> itemIdToIconResourceMap);
    199 
    200   // Helper that lists the current inspectable html pages for the extension.
    201   void GetInspectablePagesForExtensionProcess(
    202       const Extension* extension,
    203       const std::set<content::RenderViewHost*>& views,
    204       ItemInspectViewList* result);
    205 
    206   ItemInspectViewList GetInspectablePagesForExtension(
    207       const Extension* extension,
    208       bool extension_is_enabled);
    209 
    210   void GetAppWindowPagesForExtensionProfile(const Extension* extension,
    211                                             ItemInspectViewList* result);
    212 
    213   linked_ptr<developer::ItemInspectView> constructInspectView(
    214       const GURL& url,
    215       int render_process_id,
    216       int render_view_id,
    217       bool incognito,
    218       bool generated_background_page);
    219 };
    220 
    221 class DeveloperPrivateInspectFunction : public ChromeSyncExtensionFunction {
    222  public:
    223   DECLARE_EXTENSION_FUNCTION("developerPrivate.inspect",
    224                              DEVELOPERPRIVATE_INSPECT)
    225 
    226  protected:
    227   virtual ~DeveloperPrivateInspectFunction();
    228 
    229   // ExtensionFunction:
    230   virtual bool RunSync() OVERRIDE;
    231 };
    232 
    233 class DeveloperPrivateAllowFileAccessFunction
    234     : public ChromeSyncExtensionFunction {
    235  public:
    236   DECLARE_EXTENSION_FUNCTION("developerPrivate.allowFileAccess",
    237                              DEVELOPERPRIVATE_ALLOWFILEACCESS);
    238 
    239  protected:
    240   virtual ~DeveloperPrivateAllowFileAccessFunction();
    241 
    242   // ExtensionFunction:
    243   virtual bool RunSync() OVERRIDE;
    244 };
    245 
    246 class DeveloperPrivateAllowIncognitoFunction
    247     : public ChromeSyncExtensionFunction {
    248  public:
    249   DECLARE_EXTENSION_FUNCTION("developerPrivate.allowIncognito",
    250                              DEVELOPERPRIVATE_ALLOWINCOGNITO);
    251 
    252  protected:
    253   virtual ~DeveloperPrivateAllowIncognitoFunction();
    254 
    255   // ExtensionFunction:
    256   virtual bool RunSync() OVERRIDE;
    257 };
    258 
    259 class DeveloperPrivateReloadFunction : public ChromeSyncExtensionFunction {
    260  public:
    261   DECLARE_EXTENSION_FUNCTION("developerPrivate.reload",
    262                              DEVELOPERPRIVATE_RELOAD);
    263 
    264  protected:
    265   virtual ~DeveloperPrivateReloadFunction();
    266 
    267   // ExtensionFunction:
    268   virtual bool RunSync() OVERRIDE;
    269 };
    270 
    271 class DeveloperPrivateShowPermissionsDialogFunction
    272     : public ChromeSyncExtensionFunction,
    273       public ExtensionInstallPrompt::Delegate {
    274  public:
    275   DECLARE_EXTENSION_FUNCTION("developerPrivate.showPermissionsDialog",
    276                              DEVELOPERPRIVATE_PERMISSIONS);
    277 
    278   DeveloperPrivateShowPermissionsDialogFunction();
    279  protected:
    280   virtual ~DeveloperPrivateShowPermissionsDialogFunction();
    281 
    282   // ExtensionFunction:
    283   virtual bool RunSync() OVERRIDE;
    284 
    285   // Overridden from ExtensionInstallPrompt::Delegate
    286   virtual void InstallUIProceed() OVERRIDE;
    287   virtual void InstallUIAbort(bool user_initiated) OVERRIDE;
    288 
    289   scoped_ptr<ExtensionInstallPrompt> prompt_;
    290   std::string extension_id_;
    291 };
    292 
    293 class DeveloperPrivateEnableFunction
    294     : public ChromeSyncExtensionFunction,
    295       public base::SupportsWeakPtr<DeveloperPrivateEnableFunction> {
    296  public:
    297   DECLARE_EXTENSION_FUNCTION("developerPrivate.enable",
    298                              DEVELOPERPRIVATE_ENABLE);
    299 
    300   DeveloperPrivateEnableFunction();
    301 
    302  protected:
    303   virtual ~DeveloperPrivateEnableFunction();
    304 
    305   // Callback for requirements checker.
    306   void OnRequirementsChecked(const std::string& extension_id,
    307                              std::vector<std::string> requirements_errors);
    308   // ExtensionFunction:
    309   virtual bool RunSync() OVERRIDE;
    310 
    311  private:
    312   scoped_ptr<RequirementsChecker> requirements_checker_;
    313 };
    314 
    315 class DeveloperPrivateChooseEntryFunction : public ChromeAsyncExtensionFunction,
    316                                             public EntryPickerClient {
    317  protected:
    318   virtual ~DeveloperPrivateChooseEntryFunction();
    319   virtual bool RunAsync() OVERRIDE;
    320   bool ShowPicker(ui::SelectFileDialog::Type picker_type,
    321                   const base::FilePath& last_directory,
    322                   const base::string16& select_title,
    323                   const ui::SelectFileDialog::FileTypeInfo& info,
    324                   int file_type_index);
    325 
    326   // EntryPickerClient functions.
    327   virtual void FileSelected(const base::FilePath& path) = 0;
    328   virtual void FileSelectionCanceled() = 0;
    329 };
    330 
    331 
    332 class DeveloperPrivateLoadUnpackedFunction
    333     : public DeveloperPrivateChooseEntryFunction {
    334  public:
    335   DECLARE_EXTENSION_FUNCTION("developerPrivate.loadUnpacked",
    336                              DEVELOPERPRIVATE_LOADUNPACKED);
    337 
    338  protected:
    339   virtual ~DeveloperPrivateLoadUnpackedFunction();
    340   virtual bool RunAsync() OVERRIDE;
    341 
    342   // EntryPickerCLient implementation.
    343   virtual void FileSelected(const base::FilePath& path) OVERRIDE;
    344   virtual void FileSelectionCanceled() OVERRIDE;
    345 };
    346 
    347 class DeveloperPrivateChoosePathFunction
    348     : public DeveloperPrivateChooseEntryFunction {
    349  public:
    350   DECLARE_EXTENSION_FUNCTION("developerPrivate.choosePath",
    351                              DEVELOPERPRIVATE_CHOOSEPATH);
    352 
    353  protected:
    354   virtual ~DeveloperPrivateChoosePathFunction();
    355   virtual bool RunAsync() OVERRIDE;
    356 
    357   // EntryPickerClient functions.
    358   virtual void FileSelected(const base::FilePath& path) OVERRIDE;
    359   virtual void FileSelectionCanceled() OVERRIDE;
    360 };
    361 
    362 class DeveloperPrivatePackDirectoryFunction
    363     : public ChromeAsyncExtensionFunction,
    364       public PackExtensionJob::Client {
    365 
    366  public:
    367   DECLARE_EXTENSION_FUNCTION("developerPrivate.packDirectory",
    368                              DEVELOPERPRIVATE_PACKDIRECTORY);
    369 
    370   DeveloperPrivatePackDirectoryFunction();
    371 
    372   // ExtensionPackJob::Client implementation.
    373   virtual void OnPackSuccess(const base::FilePath& crx_file,
    374                              const base::FilePath& key_file) OVERRIDE;
    375   virtual void OnPackFailure(const std::string& error,
    376                              ExtensionCreator::ErrorType error_type) OVERRIDE;
    377 
    378  protected:
    379   virtual ~DeveloperPrivatePackDirectoryFunction();
    380   virtual bool RunAsync() OVERRIDE;
    381 
    382  private:
    383   scoped_refptr<PackExtensionJob> pack_job_;
    384   std::string item_path_str_;
    385   std::string key_path_str_;
    386 };
    387 
    388 class DeveloperPrivateIsProfileManagedFunction
    389     : public ChromeSyncExtensionFunction {
    390  public:
    391   DECLARE_EXTENSION_FUNCTION("developerPrivate.isProfileManaged",
    392                              DEVELOPERPRIVATE_ISPROFILEMANAGED);
    393 
    394  protected:
    395   virtual ~DeveloperPrivateIsProfileManagedFunction();
    396 
    397   // ExtensionFunction:
    398   virtual bool RunSync() OVERRIDE;
    399 };
    400 
    401 class DeveloperPrivateLoadDirectoryFunction
    402     : public ChromeAsyncExtensionFunction {
    403  public:
    404   DECLARE_EXTENSION_FUNCTION("developerPrivate.loadDirectory",
    405                              DEVELOPERPRIVATE_LOADUNPACKEDCROS);
    406 
    407   DeveloperPrivateLoadDirectoryFunction();
    408 
    409  protected:
    410   virtual ~DeveloperPrivateLoadDirectoryFunction();
    411 
    412   // ExtensionFunction:
    413   virtual bool RunAsync() OVERRIDE;
    414 
    415   bool LoadByFileSystemAPI(const storage::FileSystemURL& directory_url);
    416 
    417   void ClearExistingDirectoryContent(const base::FilePath& project_path);
    418 
    419   void ReadDirectoryByFileSystemAPI(const base::FilePath& project_path,
    420                                     const base::FilePath& destination_path);
    421 
    422   void ReadDirectoryByFileSystemAPICb(
    423       const base::FilePath& project_path,
    424       const base::FilePath& destination_path,
    425       base::File::Error result,
    426       const storage::FileSystemOperation::FileEntryList& file_list,
    427       bool has_more);
    428 
    429   void SnapshotFileCallback(
    430       const base::FilePath& target_path,
    431       base::File::Error result,
    432       const base::File::Info& file_info,
    433       const base::FilePath& platform_path,
    434       const scoped_refptr<storage::ShareableFileReference>& file_ref);
    435 
    436   void CopyFile(const base::FilePath& src_path,
    437                 const base::FilePath& dest_path);
    438 
    439   void Load();
    440 
    441   scoped_refptr<storage::FileSystemContext> context_;
    442 
    443   // syncfs url representing the root of the folder to be copied.
    444   std::string project_base_url_;
    445 
    446   // physical path on disc of the folder to be copied.
    447   base::FilePath project_base_path_;
    448 
    449  private:
    450   int pending_copy_operations_count_;
    451 
    452   // This is set to false if any of the copyFile operations fail on
    453   // call of the API. It is returned as a response of the API call.
    454   bool success_;
    455 };
    456 
    457 class DeveloperPrivateRequestFileSourceFunction
    458     : public ChromeAsyncExtensionFunction {
    459  public:
    460   DECLARE_EXTENSION_FUNCTION("developerPrivate.requestFileSource",
    461                              DEVELOPERPRIVATE_REQUESTFILESOURCE);
    462 
    463   DeveloperPrivateRequestFileSourceFunction();
    464 
    465  protected:
    466   virtual ~DeveloperPrivateRequestFileSourceFunction();
    467 
    468   // ExtensionFunction:
    469   virtual bool RunAsync() OVERRIDE;
    470 
    471  private:
    472   void LaunchCallback(const base::DictionaryValue& results);
    473 };
    474 
    475 class DeveloperPrivateOpenDevToolsFunction
    476     : public ChromeAsyncExtensionFunction {
    477  public:
    478   DECLARE_EXTENSION_FUNCTION("developerPrivate.openDevTools",
    479                              DEVELOPERPRIVATE_OPENDEVTOOLS);
    480 
    481   DeveloperPrivateOpenDevToolsFunction();
    482 
    483  protected:
    484   virtual ~DeveloperPrivateOpenDevToolsFunction();
    485 
    486   // ExtensionFunction:
    487   virtual bool RunAsync() OVERRIDE;
    488 };
    489 
    490 }  // namespace api
    491 
    492 }  // namespace extensions
    493 
    494 #endif  // CHROME_BROWSER_EXTENSIONS_API_DEVELOPER_PRIVATE_DEVELOPER_PRIVATE_API_H_
    495