Home | History | Annotate | Download | only in bookmark_manager_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_BOOKMARK_MANAGER_PRIVATE_BOOKMARK_MANAGER_PRIVATE_API_H_
      6 #define CHROME_BROWSER_EXTENSIONS_API_BOOKMARK_MANAGER_PRIVATE_BOOKMARK_MANAGER_PRIVATE_API_H_
      7 
      8 #include "base/memory/scoped_ptr.h"
      9 #include "base/values.h"
     10 #include "chrome/browser/extensions/api/bookmarks/bookmarks_api.h"
     11 #include "chrome/browser/extensions/chrome_extension_function.h"
     12 #include "chrome/browser/ui/bookmarks/bookmark_tab_helper.h"
     13 #include "chrome/browser/undo/bookmark_undo_service.h"
     14 #include "chrome/browser/undo/bookmark_undo_service_factory.h"
     15 #include "components/bookmarks/browser/base_bookmark_model_observer.h"
     16 #include "components/bookmarks/browser/bookmark_node_data.h"
     17 #include "extensions/browser/browser_context_keyed_api_factory.h"
     18 #include "extensions/browser/event_router.h"
     19 
     20 class Profile;
     21 
     22 namespace bookmarks {
     23 struct BookmarkNodeData;
     24 }
     25 
     26 namespace content {
     27 class BrowserContext;
     28 class WebContents;
     29 }
     30 
     31 namespace extensions {
     32 
     33 class BookmarkManagerPrivateEventRouter : public BaseBookmarkModelObserver {
     34  public:
     35   BookmarkManagerPrivateEventRouter(content::BrowserContext* browser_context,
     36                                     BookmarkModel* bookmark_model);
     37   virtual ~BookmarkManagerPrivateEventRouter();
     38 
     39   // BaseBookmarkModelObserver:
     40   virtual void BookmarkModelChanged() OVERRIDE;
     41   virtual void BookmarkModelBeingDeleted(BookmarkModel* model) OVERRIDE;
     42   virtual void OnWillChangeBookmarkMetaInfo(BookmarkModel* model,
     43                                             const BookmarkNode* node) OVERRIDE;
     44   virtual void BookmarkMetaInfoChanged(BookmarkModel* model,
     45                                        const BookmarkNode* node) OVERRIDE;
     46 
     47  private:
     48   // Helper to actually dispatch an event to extension listeners.
     49   void DispatchEvent(const std::string& event_name,
     50                      scoped_ptr<base::ListValue> event_args);
     51 
     52   // Remembers the previous meta info of a node before it was changed.
     53   BookmarkNode::MetaInfoMap prev_meta_info_;
     54 
     55   content::BrowserContext* browser_context_;
     56   BookmarkModel* bookmark_model_;
     57 };
     58 
     59 class BookmarkManagerPrivateAPI : public BrowserContextKeyedAPI,
     60                                   public EventRouter::Observer {
     61  public:
     62   explicit BookmarkManagerPrivateAPI(content::BrowserContext* browser_context);
     63   virtual ~BookmarkManagerPrivateAPI();
     64 
     65   // BrowserContextKeyedService implementation.
     66   virtual void Shutdown() OVERRIDE;
     67 
     68   // BrowserContextKeyedAPI implementation.
     69   static BrowserContextKeyedAPIFactory<BookmarkManagerPrivateAPI>*
     70       GetFactoryInstance();
     71 
     72   // EventRouter::Observer implementation.
     73   virtual void OnListenerAdded(const EventListenerInfo& details) OVERRIDE;
     74 
     75  private:
     76   friend class BrowserContextKeyedAPIFactory<BookmarkManagerPrivateAPI>;
     77 
     78   // BrowserContextKeyedAPI implementation.
     79   static const char* service_name() { return "BookmarkManagerPrivateAPI"; }
     80   static const bool kServiceIsNULLWhileTesting = true;
     81 
     82   content::BrowserContext* browser_context_;
     83 
     84   // Created lazily upon OnListenerAdded.
     85   scoped_ptr<BookmarkManagerPrivateEventRouter> event_router_;
     86 };
     87 
     88 // Class that handles the drag and drop related chrome.bookmarkManagerPrivate
     89 // events. This class has one instance per bookmark manager tab.
     90 class BookmarkManagerPrivateDragEventRouter
     91     : public BookmarkTabHelper::BookmarkDrag {
     92  public:
     93   BookmarkManagerPrivateDragEventRouter(Profile* profile,
     94                                         content::WebContents* web_contents);
     95   virtual ~BookmarkManagerPrivateDragEventRouter();
     96 
     97   // BookmarkTabHelper::BookmarkDrag interface
     98   virtual void OnDragEnter(const bookmarks::BookmarkNodeData& data) OVERRIDE;
     99   virtual void OnDragOver(const bookmarks::BookmarkNodeData& data) OVERRIDE;
    100   virtual void OnDragLeave(const bookmarks::BookmarkNodeData& data) OVERRIDE;
    101   virtual void OnDrop(const bookmarks::BookmarkNodeData& data) OVERRIDE;
    102 
    103   // The bookmark drag and drop data. This gets set after a drop was done on
    104   // the page. This returns NULL if no data is available.
    105   const bookmarks::BookmarkNodeData* GetBookmarkNodeData();
    106 
    107   // Clears the drag and drop data.
    108   void ClearBookmarkNodeData();
    109 
    110  private:
    111   // Helper to actually dispatch an event to extension listeners.
    112   void DispatchEvent(const std::string& event_name,
    113                      scoped_ptr<base::ListValue> args);
    114 
    115   Profile* profile_;
    116   content::WebContents* web_contents_;
    117   bookmarks::BookmarkNodeData bookmark_drag_data_;
    118 
    119   DISALLOW_COPY_AND_ASSIGN(BookmarkManagerPrivateDragEventRouter);
    120 };
    121 
    122 class ClipboardBookmarkManagerFunction : public extensions::BookmarksFunction {
    123  protected:
    124   virtual ~ClipboardBookmarkManagerFunction() {}
    125 
    126   bool CopyOrCut(bool cut, const std::vector<std::string>& id_list);
    127 };
    128 
    129 class BookmarkManagerPrivateCopyFunction
    130     : public ClipboardBookmarkManagerFunction {
    131  public:
    132   DECLARE_EXTENSION_FUNCTION("bookmarkManagerPrivate.copy",
    133                              BOOKMARKMANAGERPRIVATE_COPY)
    134 
    135  protected:
    136   virtual ~BookmarkManagerPrivateCopyFunction() {}
    137 
    138   // ExtensionFunction:
    139   virtual bool RunOnReady() OVERRIDE;
    140 };
    141 
    142 class BookmarkManagerPrivateCutFunction
    143     : public ClipboardBookmarkManagerFunction {
    144  public:
    145   DECLARE_EXTENSION_FUNCTION("bookmarkManagerPrivate.cut",
    146                              BOOKMARKMANAGERPRIVATE_CUT)
    147 
    148  protected:
    149   virtual ~BookmarkManagerPrivateCutFunction() {}
    150 
    151   // ExtensionFunction:
    152   virtual bool RunOnReady() OVERRIDE;
    153 };
    154 
    155 class BookmarkManagerPrivatePasteFunction
    156     : public extensions::BookmarksFunction {
    157  public:
    158   DECLARE_EXTENSION_FUNCTION("bookmarkManagerPrivate.paste",
    159                              BOOKMARKMANAGERPRIVATE_PASTE)
    160 
    161  protected:
    162   virtual ~BookmarkManagerPrivatePasteFunction() {}
    163 
    164   // ExtensionFunction:
    165   virtual bool RunOnReady() OVERRIDE;
    166 };
    167 
    168 class BookmarkManagerPrivateCanPasteFunction
    169     : public extensions::BookmarksFunction {
    170  public:
    171   DECLARE_EXTENSION_FUNCTION("bookmarkManagerPrivate.canPaste",
    172                              BOOKMARKMANAGERPRIVATE_CANPASTE)
    173 
    174  protected:
    175   virtual ~BookmarkManagerPrivateCanPasteFunction() {}
    176 
    177   // ExtensionFunction:
    178   virtual bool RunOnReady() OVERRIDE;
    179 };
    180 
    181 class BookmarkManagerPrivateSortChildrenFunction
    182     : public extensions::BookmarksFunction {
    183  public:
    184   DECLARE_EXTENSION_FUNCTION("bookmarkManagerPrivate.sortChildren",
    185                              BOOKMARKMANAGERPRIVATE_SORTCHILDREN)
    186 
    187  protected:
    188   virtual ~BookmarkManagerPrivateSortChildrenFunction() {}
    189 
    190   // ExtensionFunction:
    191   virtual bool RunOnReady() OVERRIDE;
    192 };
    193 
    194 class BookmarkManagerPrivateGetStringsFunction : public AsyncExtensionFunction {
    195  public:
    196   DECLARE_EXTENSION_FUNCTION("bookmarkManagerPrivate.getStrings",
    197                              BOOKMARKMANAGERPRIVATE_GETSTRINGS)
    198 
    199  protected:
    200   virtual ~BookmarkManagerPrivateGetStringsFunction() {}
    201 
    202   // ExtensionFunction:
    203   virtual bool RunAsync() OVERRIDE;
    204 };
    205 
    206 class BookmarkManagerPrivateStartDragFunction
    207     : public extensions::BookmarksFunction {
    208  public:
    209   DECLARE_EXTENSION_FUNCTION("bookmarkManagerPrivate.startDrag",
    210                              BOOKMARKMANAGERPRIVATE_STARTDRAG)
    211 
    212  protected:
    213   virtual ~BookmarkManagerPrivateStartDragFunction() {}
    214 
    215   // ExtensionFunction:
    216   virtual bool RunOnReady() OVERRIDE;
    217 };
    218 
    219 class BookmarkManagerPrivateDropFunction
    220     : public extensions::BookmarksFunction {
    221  public:
    222   DECLARE_EXTENSION_FUNCTION("bookmarkManagerPrivate.drop",
    223                              BOOKMARKMANAGERPRIVATE_DROP)
    224 
    225  protected:
    226   virtual ~BookmarkManagerPrivateDropFunction() {}
    227 
    228   // ExtensionFunction:
    229   virtual bool RunOnReady() OVERRIDE;
    230 };
    231 
    232 class BookmarkManagerPrivateGetSubtreeFunction
    233     : public extensions::BookmarksFunction {
    234  public:
    235   DECLARE_EXTENSION_FUNCTION("bookmarkManagerPrivate.getSubtree",
    236                              BOOKMARKMANAGERPRIVATE_GETSUBTREE)
    237 
    238  protected:
    239   virtual ~BookmarkManagerPrivateGetSubtreeFunction() {}
    240 
    241   // ExtensionFunction:
    242   virtual bool RunOnReady() OVERRIDE;
    243 };
    244 
    245 class BookmarkManagerPrivateCanEditFunction
    246     : public extensions::BookmarksFunction {
    247  public:
    248   DECLARE_EXTENSION_FUNCTION("bookmarkManagerPrivate.canEdit",
    249                              BOOKMARKMANAGERPRIVATE_CANEDIT)
    250 
    251  protected:
    252   virtual ~BookmarkManagerPrivateCanEditFunction() {}
    253 
    254   // ExtensionFunction:
    255   virtual bool RunOnReady() OVERRIDE;
    256 };
    257 
    258 class BookmarkManagerPrivateRecordLaunchFunction
    259     : public extensions::BookmarksFunction {
    260  public:
    261   DECLARE_EXTENSION_FUNCTION("bookmarkManagerPrivate.recordLaunch",
    262                              BOOKMARKMANAGERPRIVATE_RECORDLAUNCH)
    263 
    264  protected:
    265   virtual ~BookmarkManagerPrivateRecordLaunchFunction() {}
    266 
    267   // ExtensionFunction:
    268   virtual bool RunOnReady() OVERRIDE;
    269 };
    270 
    271 class BookmarkManagerPrivateCreateWithMetaInfoFunction
    272     : public extensions::BookmarksFunction {
    273  public:
    274   DECLARE_EXTENSION_FUNCTION("bookmarkManagerPrivate.createWithMetaInfo",
    275                              BOOKMARKMANAGERPRIVATE_CREATEWITHMETAINFO)
    276 
    277  protected:
    278   virtual ~BookmarkManagerPrivateCreateWithMetaInfoFunction() {}
    279 
    280   // ExtensionFunction:
    281   virtual bool RunOnReady() OVERRIDE;
    282 };
    283 
    284 class BookmarkManagerPrivateGetMetaInfoFunction
    285     : public extensions::BookmarksFunction {
    286  public:
    287   DECLARE_EXTENSION_FUNCTION("bookmarkManagerPrivate.getMetaInfo",
    288                              BOOKMARKMANAGERPRIVATE_GETMETAINFO)
    289 
    290  protected:
    291   virtual ~BookmarkManagerPrivateGetMetaInfoFunction() {}
    292 
    293   // ExtensionFunction:
    294   virtual bool RunOnReady() OVERRIDE;
    295 };
    296 
    297 class BookmarkManagerPrivateSetMetaInfoFunction
    298     : public extensions::BookmarksFunction {
    299  public:
    300   DECLARE_EXTENSION_FUNCTION("bookmarkManagerPrivate.setMetaInfo",
    301                              BOOKMARKMANAGERPRIVATE_SETMETAINFO)
    302 
    303  protected:
    304   virtual ~BookmarkManagerPrivateSetMetaInfoFunction() {}
    305 
    306   // ExtensionFunction:
    307   virtual bool RunOnReady() OVERRIDE;
    308 };
    309 
    310 class BookmarkManagerPrivateUpdateMetaInfoFunction
    311     : public extensions::BookmarksFunction {
    312  public:
    313   DECLARE_EXTENSION_FUNCTION("bookmarkManagerPrivate.updateMetaInfo",
    314                              BOOKMARKMANAGERPRIVATE_UPDATEMETAINFO)
    315 
    316  protected:
    317   virtual ~BookmarkManagerPrivateUpdateMetaInfoFunction() {}
    318 
    319   // ExtensionFunction:
    320   virtual bool RunOnReady() OVERRIDE;
    321 };
    322 
    323 class BookmarkManagerPrivateCanOpenNewWindowsFunction
    324     : public extensions::BookmarksFunction {
    325  public:
    326   DECLARE_EXTENSION_FUNCTION("bookmarkManagerPrivate.canOpenNewWindows",
    327                              BOOKMARKMANAGERPRIVATE_CANOPENNEWWINDOWS)
    328 
    329  protected:
    330   virtual ~BookmarkManagerPrivateCanOpenNewWindowsFunction() {}
    331 
    332   // ExtensionFunction:
    333   virtual bool RunOnReady() OVERRIDE;
    334 };
    335 
    336 class BookmarkManagerPrivateRemoveTreesFunction
    337     : public extensions::BookmarksFunction {
    338  public:
    339   DECLARE_EXTENSION_FUNCTION("bookmarkManagerPrivate.removeTrees",
    340                              BOOKMARKMANAGERPRIVATE_REMOVETREES)
    341 
    342  protected:
    343   virtual ~BookmarkManagerPrivateRemoveTreesFunction() {}
    344 
    345   // ExtensionFunction:
    346   virtual bool RunOnReady() OVERRIDE;
    347 };
    348 
    349 class BookmarkManagerPrivateUndoFunction
    350     : public extensions::BookmarksFunction {
    351  public:
    352   DECLARE_EXTENSION_FUNCTION("bookmarkManagerPrivate.undo",
    353                              BOOKMARKMANAGERPRIVATE_UNDO)
    354 
    355  protected:
    356   virtual ~BookmarkManagerPrivateUndoFunction() {}
    357 
    358   // ExtensionFunction:
    359   virtual bool RunOnReady() OVERRIDE;
    360 };
    361 
    362 class BookmarkManagerPrivateRedoFunction
    363     : public extensions::BookmarksFunction {
    364  public:
    365   DECLARE_EXTENSION_FUNCTION("bookmarkManagerPrivate.redo",
    366                              BOOKMARKMANAGERPRIVATE_REDO)
    367 
    368  protected:
    369   virtual ~BookmarkManagerPrivateRedoFunction() {}
    370 
    371   // ExtensionFunction:
    372   virtual bool RunOnReady() OVERRIDE;
    373 };
    374 
    375 class BookmarkManagerPrivateGetUndoInfoFunction
    376     : public extensions::BookmarksFunction {
    377  public:
    378   DECLARE_EXTENSION_FUNCTION("bookmarkManagerPrivate.getUndoInfo",
    379                              BOOKMARKMANAGERPRIVATE_UNDOINFO)
    380 
    381  protected:
    382   virtual ~BookmarkManagerPrivateGetUndoInfoFunction() {}
    383 
    384   // ExtensionFunction:
    385   virtual bool RunOnReady() OVERRIDE;
    386 };
    387 
    388 class BookmarkManagerPrivateGetRedoInfoFunction
    389     : public extensions::BookmarksFunction {
    390  public:
    391   DECLARE_EXTENSION_FUNCTION("bookmarkManagerPrivate.getRedoInfo",
    392                              BOOKMARKMANAGERPRIVATE_REDOINFO)
    393 
    394  protected:
    395   virtual ~BookmarkManagerPrivateGetRedoInfoFunction() {}
    396 
    397   // ExtensionFunction:
    398   virtual bool RunOnReady() OVERRIDE;
    399 };
    400 
    401 }  // namespace extensions
    402 
    403 #endif  // CHROME_BROWSER_EXTENSIONS_API_BOOKMARK_MANAGER_PRIVATE_BOOKMARK_MANAGER_PRIVATE_API_H_
    404