bookmarks_api.h revision 0529e5d033099cbfc42635f6f6183833b09dff6e 
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_BOOKMARKS_BOOKMARKS_API_H_
6#define CHROME_BROWSER_EXTENSIONS_API_BOOKMARKS_BOOKMARKS_API_H_
7
8#include <list>
9#include <string>
10#include <vector>
11
12#include "base/compiler_specific.h"
13#include "base/memory/ref_counted.h"
14#include "chrome/browser/bookmarks/base_bookmark_model_observer.h"
15#include "chrome/browser/extensions/chrome_extension_function.h"
16#include "components/bookmarks/core/browser/bookmark_node.h"
17#include "extensions/browser/browser_context_keyed_api_factory.h"
18#include "extensions/browser/event_router.h"
19#include "ui/shell_dialogs/select_file_dialog.h"
20
21namespace base {
22class FilePath;
23class ListValue;
24}
25
26namespace content {
27class BrowserContext;
28}
29
30namespace extensions {
31
32namespace api {
33namespace bookmarks {
34struct CreateDetails;
35}
36}
37
38// Observes BookmarkModel and then routes the notifications as events to
39// the extension system.
40class BookmarkEventRouter : public BookmarkModelObserver {
41 public:
42  BookmarkEventRouter(content::BrowserContext* context, BookmarkModel* model);
43  virtual ~BookmarkEventRouter();
44
45  // BookmarkModelObserver:
46  virtual void BookmarkModelLoaded(BookmarkModel* model,
47                                   bool ids_reassigned) OVERRIDE;
48  virtual void BookmarkModelBeingDeleted(BookmarkModel* model) OVERRIDE;
49  virtual void BookmarkNodeMoved(BookmarkModel* model,
50                                 const BookmarkNode* old_parent,
51                                 int old_index,
52                                 const BookmarkNode* new_parent,
53                                 int new_index) OVERRIDE;
54  virtual void BookmarkNodeAdded(BookmarkModel* model,
55                                 const BookmarkNode* parent,
56                                 int index) OVERRIDE;
57  virtual void BookmarkNodeRemoved(BookmarkModel* model,
58                                   const BookmarkNode* parent,
59                                   int old_index,
60                                   const BookmarkNode* node) OVERRIDE;
61  virtual void BookmarkAllNodesRemoved(BookmarkModel* model) OVERRIDE;
62  virtual void BookmarkNodeChanged(BookmarkModel* model,
63                                   const BookmarkNode* node) OVERRIDE;
64  virtual void BookmarkNodeFaviconChanged(BookmarkModel* model,
65                                          const BookmarkNode* node) OVERRIDE;
66  virtual void BookmarkNodeChildrenReordered(BookmarkModel* model,
67                                             const BookmarkNode* node) OVERRIDE;
68  virtual void ExtensiveBookmarkChangesBeginning(BookmarkModel* model) OVERRIDE;
69  virtual void ExtensiveBookmarkChangesEnded(BookmarkModel* model) OVERRIDE;
70
71 private:
72  // Helper to actually dispatch an event to extension listeners.
73  void DispatchEvent(const std::string& event_name,
74                     scoped_ptr<base::ListValue> event_args);
75
76  content::BrowserContext* browser_context_;
77  BookmarkModel* model_;
78
79  DISALLOW_COPY_AND_ASSIGN(BookmarkEventRouter);
80};
81
82class BookmarksAPI : public BrowserContextKeyedAPI,
83                     public EventRouter::Observer {
84 public:
85  explicit BookmarksAPI(content::BrowserContext* context);
86  virtual ~BookmarksAPI();
87
88  // KeyedService implementation.
89  virtual void Shutdown() OVERRIDE;
90
91  // BrowserContextKeyedAPI implementation.
92  static BrowserContextKeyedAPIFactory<BookmarksAPI>* GetFactoryInstance();
93
94  // EventRouter::Observer implementation.
95  virtual void OnListenerAdded(
96      const EventListenerInfo& details) OVERRIDE;
97
98 private:
99  friend class BrowserContextKeyedAPIFactory<BookmarksAPI>;
100
101  content::BrowserContext* browser_context_;
102
103  // BrowserContextKeyedAPI implementation.
104  static const char* service_name() {
105    return "BookmarksAPI";
106  }
107  static const bool kServiceIsNULLWhileTesting = true;
108
109  // Created lazily upon OnListenerAdded.
110  scoped_ptr<BookmarkEventRouter> bookmark_event_router_;
111};
112
113class BookmarksFunction : public ChromeAsyncExtensionFunction,
114                          public BaseBookmarkModelObserver {
115 public:
116  // AsyncExtensionFunction:
117  virtual void Run() OVERRIDE;
118
119 protected:
120  virtual ~BookmarksFunction() {}
121
122  // Helper to get the bookmark id as int64 from the given string id.
123  // Sets error_ to an error string if the given id string can't be parsed
124  // as an int64. In case of error, doesn't change id and returns false.
125  bool GetBookmarkIdAsInt64(const std::string& id_string, int64* id);
126
127  // Helper to get the bookmark node from a given string id.
128  // If the given id can't be parsed or doesn't refer to a valid node, sets
129  // error_ and returns NULL.
130  const BookmarkNode* GetBookmarkNodeFromId(const std::string& id_string);
131
132  // Helper to create a bookmark node from a CreateDetails object. If a node
133  // can't be created based on the given details, sets error_ and returns NULL.
134  const BookmarkNode* CreateBookmarkNode(
135      BookmarkModel* model,
136      const api::bookmarks::CreateDetails& details,
137      const BookmarkNode::MetaInfoMap* meta_info);
138
139  // Helper that checks if bookmark editing is enabled. If it's not, this sets
140  // error_ to the appropriate error string.
141  bool EditBookmarksEnabled();
142
143 private:
144  // BaseBookmarkModelObserver:
145  virtual void BookmarkModelChanged() OVERRIDE;
146  virtual void BookmarkModelLoaded(BookmarkModel* model,
147                                   bool ids_reassigned) OVERRIDE;
148};
149
150class BookmarksGetFunction : public BookmarksFunction {
151 public:
152  DECLARE_EXTENSION_FUNCTION("bookmarks.get", BOOKMARKS_GET)
153
154 protected:
155  virtual ~BookmarksGetFunction() {}
156
157  // ExtensionFunction:
158  virtual bool RunImpl() OVERRIDE;
159};
160
161class BookmarksGetChildrenFunction : public BookmarksFunction {
162 public:
163  DECLARE_EXTENSION_FUNCTION("bookmarks.getChildren", BOOKMARKS_GETCHILDREN)
164
165 protected:
166  virtual ~BookmarksGetChildrenFunction() {}
167
168  // ExtensionFunction:
169  virtual bool RunImpl() OVERRIDE;
170};
171
172class BookmarksGetRecentFunction : public BookmarksFunction {
173 public:
174  DECLARE_EXTENSION_FUNCTION("bookmarks.getRecent", BOOKMARKS_GETRECENT)
175
176 protected:
177  virtual ~BookmarksGetRecentFunction() {}
178
179  // ExtensionFunction:
180  virtual bool RunImpl() OVERRIDE;
181};
182
183class BookmarksGetTreeFunction : public BookmarksFunction {
184 public:
185  DECLARE_EXTENSION_FUNCTION("bookmarks.getTree", BOOKMARKS_GETTREE)
186
187 protected:
188  virtual ~BookmarksGetTreeFunction() {}
189
190  // ExtensionFunction:
191  virtual bool RunImpl() OVERRIDE;
192};
193
194class BookmarksGetSubTreeFunction : public BookmarksFunction {
195 public:
196  DECLARE_EXTENSION_FUNCTION("bookmarks.getSubTree", BOOKMARKS_GETSUBTREE)
197
198 protected:
199  virtual ~BookmarksGetSubTreeFunction() {}
200
201  // ExtensionFunction:
202  virtual bool RunImpl() OVERRIDE;
203};
204
205class BookmarksSearchFunction : public BookmarksFunction {
206 public:
207  DECLARE_EXTENSION_FUNCTION("bookmarks.search", BOOKMARKS_SEARCH)
208
209 protected:
210  virtual ~BookmarksSearchFunction() {}
211
212  // ExtensionFunction:
213  virtual bool RunImpl() OVERRIDE;
214};
215
216class BookmarksRemoveFunction : public BookmarksFunction {
217 public:
218  DECLARE_EXTENSION_FUNCTION("bookmarks.remove", BOOKMARKS_REMOVE)
219
220  // Returns true on successful parse and sets invalid_id to true if conversion
221  // from id string to int64 failed.
222  static bool ExtractIds(const base::ListValue* args,
223                         std::list<int64>* ids,
224                         bool* invalid_id);
225  // ExtensionFunction:
226  virtual void GetQuotaLimitHeuristics(
227      QuotaLimitHeuristics* heuristics) const OVERRIDE;
228
229 protected:
230  virtual ~BookmarksRemoveFunction() {}
231
232  // ExtensionFunction:
233  virtual bool RunImpl() OVERRIDE;
234};
235
236class BookmarksRemoveTreeFunction : public BookmarksRemoveFunction {
237 public:
238  DECLARE_EXTENSION_FUNCTION("bookmarks.removeTree", BOOKMARKS_REMOVETREE)
239
240 protected:
241  virtual ~BookmarksRemoveTreeFunction() {}
242};
243
244class BookmarksCreateFunction : public BookmarksFunction {
245 public:
246  DECLARE_EXTENSION_FUNCTION("bookmarks.create", BOOKMARKS_CREATE)
247
248  // ExtensionFunction:
249  virtual void GetQuotaLimitHeuristics(
250      QuotaLimitHeuristics* heuristics) const OVERRIDE;
251
252 protected:
253  virtual ~BookmarksCreateFunction() {}
254
255  // ExtensionFunction:
256  virtual bool RunImpl() OVERRIDE;
257};
258
259class BookmarksMoveFunction : public BookmarksFunction {
260 public:
261  DECLARE_EXTENSION_FUNCTION("bookmarks.move", BOOKMARKS_MOVE)
262
263  static bool ExtractIds(const base::ListValue* args,
264                         std::list<int64>* ids,
265                         bool* invalid_id);
266
267  // ExtensionFunction:
268  virtual void GetQuotaLimitHeuristics(
269      QuotaLimitHeuristics* heuristics) const OVERRIDE;
270
271 protected:
272  virtual ~BookmarksMoveFunction() {}
273
274  // ExtensionFunction:
275  virtual bool RunImpl() OVERRIDE;
276};
277
278class BookmarksUpdateFunction : public BookmarksFunction {
279 public:
280  DECLARE_EXTENSION_FUNCTION("bookmarks.update", BOOKMARKS_UPDATE)
281
282  static bool ExtractIds(const base::ListValue* args,
283                         std::list<int64>* ids,
284                         bool* invalid_id);
285
286  // ExtensionFunction:
287  virtual void GetQuotaLimitHeuristics(
288      QuotaLimitHeuristics* heuristics) const OVERRIDE;
289
290 protected:
291  virtual ~BookmarksUpdateFunction() {}
292
293  // ExtensionFunction:
294  virtual bool RunImpl() OVERRIDE;
295};
296
297class BookmarksIOFunction : public BookmarksFunction,
298                            public ui::SelectFileDialog::Listener {
299 public:
300  BookmarksIOFunction();
301
302  virtual void FileSelected(const base::FilePath& path, int index, void* params) = 0;
303
304  // ui::SelectFileDialog::Listener:
305  virtual void MultiFilesSelected(const std::vector<base::FilePath>& files,
306                                  void* params) OVERRIDE;
307  virtual void FileSelectionCanceled(void* params) OVERRIDE;
308
309  void SelectFile(ui::SelectFileDialog::Type type);
310
311 protected:
312  virtual ~BookmarksIOFunction();
313
314 private:
315  void ShowSelectFileDialog(
316      ui::SelectFileDialog::Type type,
317      const base::FilePath& default_path);
318
319 protected:
320  scoped_refptr<ui::SelectFileDialog> select_file_dialog_;
321};
322
323class BookmarksImportFunction : public BookmarksIOFunction {
324 public:
325  DECLARE_EXTENSION_FUNCTION("bookmarks.import", BOOKMARKS_IMPORT)
326
327  // BookmarkManagerIOFunction:
328  virtual void FileSelected(const base::FilePath& path,
329                            int index,
330                            void* params) OVERRIDE;
331
332 private:
333  virtual ~BookmarksImportFunction() {}
334
335  // ExtensionFunction:
336  virtual bool RunImpl() OVERRIDE;
337};
338
339class BookmarksExportFunction : public BookmarksIOFunction {
340 public:
341  DECLARE_EXTENSION_FUNCTION("bookmarks.export", BOOKMARKS_EXPORT)
342
343  // BookmarkManagerIOFunction:
344  virtual void FileSelected(const base::FilePath& path,
345                            int index,
346                            void* params) OVERRIDE;
347
348 private:
349  virtual ~BookmarksExportFunction() {}
350
351  // ExtensionFunction:
352  virtual bool RunImpl() OVERRIDE;
353};
354
355}  // namespace extensions
356
357#endif  // CHROME_BROWSER_EXTENSIONS_API_BOOKMARKS_BOOKMARKS_API_H_
358