1 // Copyright (c) 2011 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_EXTENSION_BOOKMARKS_MODULE_H_ 6 #define CHROME_BROWSER_EXTENSIONS_EXTENSION_BOOKMARKS_MODULE_H_ 7 #pragma once 8 9 #include <list> 10 #include <set> 11 #include <string> 12 13 #include "base/compiler_specific.h" 14 #include "base/memory/ref_counted.h" 15 #include "base/memory/singleton.h" 16 #include "chrome/browser/bookmarks/bookmark_model_observer.h" 17 #include "chrome/browser/extensions/extension_function.h" 18 #include "chrome/browser/ui/shell_dialogs.h" 19 #include "content/common/notification_observer.h" 20 #include "content/common/notification_registrar.h" 21 22 class FilePath; 23 24 // Observes BookmarkModel and then routes the notifications as events to 25 // the extension system. 26 class ExtensionBookmarkEventRouter : public BookmarkModelObserver { 27 public: 28 static ExtensionBookmarkEventRouter* GetInstance(); 29 virtual ~ExtensionBookmarkEventRouter(); 30 31 // Call this for each model to observe. Safe to call multiple times per 32 // model. 33 void Observe(BookmarkModel* model); 34 35 // BookmarkModelObserver: 36 virtual void Loaded(BookmarkModel* model) OVERRIDE; BookmarkModelBeingDeleted(BookmarkModel * model)37 virtual void BookmarkModelBeingDeleted(BookmarkModel* model) OVERRIDE {} 38 virtual void BookmarkNodeMoved(BookmarkModel* model, 39 const BookmarkNode* old_parent, 40 int old_index, 41 const BookmarkNode* new_parent, 42 int new_index) OVERRIDE; 43 virtual void BookmarkNodeAdded(BookmarkModel* model, 44 const BookmarkNode* parent, 45 int index) OVERRIDE; 46 virtual void BookmarkNodeRemoved(BookmarkModel* model, 47 const BookmarkNode* parent, 48 int old_index, 49 const BookmarkNode* node) OVERRIDE; 50 virtual void BookmarkNodeChanged(BookmarkModel* model, 51 const BookmarkNode* node) OVERRIDE; 52 virtual void BookmarkNodeFaviconLoaded(BookmarkModel* model, 53 const BookmarkNode* node) OVERRIDE; 54 virtual void BookmarkNodeChildrenReordered(BookmarkModel* model, 55 const BookmarkNode* node) OVERRIDE; 56 virtual void BookmarkImportBeginning(BookmarkModel* model) OVERRIDE; 57 virtual void BookmarkImportEnding(BookmarkModel* model) OVERRIDE; 58 59 private: 60 ExtensionBookmarkEventRouter(); 61 friend struct DefaultSingletonTraits<ExtensionBookmarkEventRouter>; 62 63 // Helper to actually dispatch an event to extension listeners. 64 void DispatchEvent(Profile* profile, 65 const char* event_name, 66 const std::string& json_args); 67 68 // These are stored so that Observe can be called multiple times safely. 69 // This way the caller doesn't have to know whether it's already observing 70 // a particular model or not. The pointers are not owned by this object. 71 std::set<BookmarkModel*> models_; 72 73 DISALLOW_COPY_AND_ASSIGN(ExtensionBookmarkEventRouter); 74 }; 75 76 class BookmarksFunction : public AsyncExtensionFunction, 77 public NotificationObserver { 78 public: 79 // AsyncExtensionFunction: 80 virtual void Run() OVERRIDE; 81 82 virtual bool RunImpl() = 0; 83 84 protected: 85 // Helper to get the bookmark id as int64 from the given string id. 86 // Sets error_ to an error string if the given id string can't be parsed 87 // as an int64. In case of error, doesn't change id and returns false. 88 bool GetBookmarkIdAsInt64(const std::string& id_string, int64* id); 89 90 // Helper that checks if bookmark editing is enabled. If it's not, this sets 91 // error_ to the appropriate error string. 92 bool EditBookmarksEnabled(); 93 94 private: 95 // NotificationObserver: 96 virtual void Observe(NotificationType type, 97 const NotificationSource& source, 98 const NotificationDetails& details) OVERRIDE; 99 100 NotificationRegistrar registrar_; 101 }; 102 103 class GetBookmarksFunction : public BookmarksFunction { 104 public: 105 virtual bool RunImpl() OVERRIDE; 106 107 private: 108 DECLARE_EXTENSION_FUNCTION_NAME("bookmarks.get") 109 }; 110 111 class GetBookmarkChildrenFunction : public BookmarksFunction { 112 public: 113 virtual bool RunImpl() OVERRIDE; 114 115 private: 116 DECLARE_EXTENSION_FUNCTION_NAME("bookmarks.getChildren") 117 }; 118 119 class GetBookmarkRecentFunction : public BookmarksFunction { 120 public: 121 virtual bool RunImpl() OVERRIDE; 122 123 private: 124 DECLARE_EXTENSION_FUNCTION_NAME("bookmarks.getRecent") 125 }; 126 127 class GetBookmarkTreeFunction : public BookmarksFunction { 128 public: 129 virtual bool RunImpl() OVERRIDE; 130 131 private: 132 DECLARE_EXTENSION_FUNCTION_NAME("bookmarks.getTree") 133 }; 134 135 class SearchBookmarksFunction : public BookmarksFunction { 136 public: 137 virtual bool RunImpl() OVERRIDE; 138 139 private: 140 DECLARE_EXTENSION_FUNCTION_NAME("bookmarks.search") 141 }; 142 143 class RemoveBookmarkFunction : public BookmarksFunction { 144 public: 145 // Returns true on successful parse and sets invalid_id to true if conversion 146 // from id string to int64 failed. 147 static bool ExtractIds(const ListValue* args, std::list<int64>* ids, 148 bool* invalid_id); 149 // BookmarksFunction: 150 virtual bool RunImpl() OVERRIDE; 151 virtual void GetQuotaLimitHeuristics( 152 std::list<QuotaLimitHeuristic*>* heuristics) const; 153 154 private: 155 DECLARE_EXTENSION_FUNCTION_NAME("bookmarks.remove") 156 }; 157 158 class RemoveTreeBookmarkFunction : public RemoveBookmarkFunction { 159 DECLARE_EXTENSION_FUNCTION_NAME("bookmarks.removeTree") 160 }; 161 162 class CreateBookmarkFunction : public BookmarksFunction { 163 public: 164 virtual void GetQuotaLimitHeuristics( 165 std::list<QuotaLimitHeuristic*>* heuristics) const; 166 // BookmarksFunction: 167 virtual bool RunImpl() OVERRIDE; 168 169 private: 170 DECLARE_EXTENSION_FUNCTION_NAME("bookmarks.create") 171 }; 172 173 class MoveBookmarkFunction : public BookmarksFunction { 174 public: 175 static bool ExtractIds(const ListValue* args, std::list<int64>* ids, 176 bool* invalid_id); 177 virtual void GetQuotaLimitHeuristics( 178 std::list<QuotaLimitHeuristic*>* heuristics) const; 179 // BookmarksFunction: 180 virtual bool RunImpl() OVERRIDE; 181 182 private: 183 DECLARE_EXTENSION_FUNCTION_NAME("bookmarks.move") 184 }; 185 186 class UpdateBookmarkFunction : public BookmarksFunction { 187 public: 188 static bool ExtractIds(const ListValue* args, std::list<int64>* ids, 189 bool* invalid_id); 190 virtual void GetQuotaLimitHeuristics( 191 std::list<QuotaLimitHeuristic*>* heuristics) const; 192 virtual bool RunImpl(); 193 private: 194 DECLARE_EXTENSION_FUNCTION_NAME("bookmarks.update") 195 }; 196 197 class BookmarksIOFunction : public BookmarksFunction, 198 public SelectFileDialog::Listener { 199 public: 200 BookmarksIOFunction(); 201 virtual ~BookmarksIOFunction(); 202 203 virtual void FileSelected(const FilePath& path, int index, void* params) = 0; 204 205 // SelectFileDialog::Listener: 206 virtual void MultiFilesSelected(const std::vector<FilePath>& files, 207 void* params) OVERRIDE; 208 virtual void FileSelectionCanceled(void* params) OVERRIDE; 209 210 void SelectFile(SelectFileDialog::Type type); 211 212 private: 213 void ShowSelectFileDialog(SelectFileDialog::Type type, FilePath default_path); 214 215 protected: 216 scoped_refptr<SelectFileDialog> select_file_dialog_; 217 }; 218 219 class ImportBookmarksFunction : public BookmarksIOFunction { 220 public: 221 // BookmarkManagerIOFunction: 222 virtual bool RunImpl() OVERRIDE; 223 virtual void FileSelected(const FilePath& path, int index, void* params) 224 OVERRIDE; 225 226 private: 227 DECLARE_EXTENSION_FUNCTION_NAME("bookmarks.import"); 228 }; 229 230 class ExportBookmarksFunction : public BookmarksIOFunction { 231 public: 232 // BookmarkManagerIOFunction: 233 virtual bool RunImpl() OVERRIDE; 234 virtual void FileSelected(const FilePath& path, int index, void* params) 235 OVERRIDE; 236 237 private: 238 DECLARE_EXTENSION_FUNCTION_NAME("bookmarks.export"); 239 }; 240 241 #endif // CHROME_BROWSER_EXTENSIONS_EXTENSION_BOOKMARKS_MODULE_H_ 242