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_HISTORY_ANDROID_ANDROID_PROVIDER_BACKEND_H_ 6 #define CHROME_BROWSER_HISTORY_ANDROID_ANDROID_PROVIDER_BACKEND_H_ 7 8 #include <list> 9 #include <set> 10 11 #include "base/containers/hash_tables.h" 12 #include "base/files/file_path.h" 13 #include "base/gtest_prod_util.h" 14 #include "base/memory/ref_counted.h" 15 #include "base/memory/scoped_ptr.h" 16 #include "base/memory/scoped_vector.h" 17 #include "chrome/browser/history/android/android_cache_database.h" 18 #include "chrome/browser/history/android/sql_handler.h" 19 #include "chrome/browser/history/history_backend.h" 20 #include "chrome/browser/history/history_notifications.h" 21 #include "components/history/core/android/android_history_types.h" 22 #include "sql/statement.h" 23 #include "sql/transaction.h" 24 25 namespace history { 26 27 class AndroidProviderBackend; 28 class AndroidURLsSQLHandler; 29 class HistoryClient; 30 class HistoryDatabase; 31 class ThumbnailDatabase; 32 33 // This class provides the query/insert/update/remove methods to implement 34 // android.provider.Browser.BookmarkColumns and 35 // android.provider.Browser.SearchColumns API. 36 // 37 // When used it: 38 // a. The android_urls table is created in history database if it doesn't 39 // exists. 40 // b. The android_cache database is created. 41 // c. The bookmark_cache table is created. 42 // 43 // Android_urls and android_cache database is only updated before the related 44 // methods are accessed. A data change will not triger the update. 45 // 46 // The android_cache database is deleted when shutdown. 47 class AndroidProviderBackend { 48 public: 49 AndroidProviderBackend(const base::FilePath& cache_db_name, 50 HistoryDatabase* history_db, 51 ThumbnailDatabase* thumbnail_db, 52 HistoryClient* history_client_, 53 HistoryBackend::Delegate* delegate); 54 55 ~AndroidProviderBackend(); 56 57 // Bookmarks ---------------------------------------------------------------- 58 // 59 // Runs the given query and returns the result on success, NULL on error or 60 // the |projections| is empty. 61 // 62 // |projections| is the vector of the result columns. 63 // |selection| is the SQL WHERE clause without 'WHERE'. 64 // |selection_args| is the arguments for WHERE clause. 65 // |sort_order| is the SQL ORDER clause. 66 AndroidStatement* QueryHistoryAndBookmarks( 67 const std::vector<HistoryAndBookmarkRow::ColumnID>& projections, 68 const std::string& selection, 69 const std::vector<base::string16>& selection_args, 70 const std::string& sort_order); 71 72 // Runs the given update and returns the number of the updated rows in 73 // |update_count| and return true on success, false on error. 74 // 75 // |row| is the value to update. 76 // |selection| is the SQL WHERE clause without 'WHERE'. 77 // |selection_args| is the arguments for the WHERE clause. 78 bool UpdateHistoryAndBookmarks( 79 const HistoryAndBookmarkRow& row, 80 const std::string& selection, 81 const std::vector<base::string16>& selection_args, 82 int* update_count); 83 84 // Inserts the given values and returns the URLID of the inserted row. 85 AndroidURLID InsertHistoryAndBookmark(const HistoryAndBookmarkRow& values); 86 87 // Deletes the specified rows and returns the number of the deleted rows in 88 // |deleted_count|. 89 // |selection| is the SQL WHERE clause without 'WHERE'. 90 // |selection_args| is the arguments for the WHERE clause. 91 // 92 // if |selection| is empty all history and bookmarks are deleted. 93 bool DeleteHistoryAndBookmarks( 94 const std::string& selection, 95 const std::vector<base::string16>& selection_args, 96 int* deleted_count); 97 98 // Deletes the matched history, returns true on success, false on error. 99 // The number of deleted row is returned in |deleted_count|. 100 // The url row is kept and the visit count is reset if the matched url 101 // is bookmarked. 102 bool DeleteHistory(const std::string& selection, 103 const std::vector<base::string16>& selection_args, 104 int* deleted_count); 105 106 // SearchTerms -------------------------------------------------------------- 107 // 108 // Returns the result of the given query. 109 // |projections| specifies the result columns, can not be empty, otherwise 110 // NULL is returned. 111 // |selection| is the SQL WHERE clause without 'WHERE'. 112 // |selection_args| is the arguments for WHERE clause. 113 // |sort_order| the SQL ORDER clause. 114 AndroidStatement* QuerySearchTerms( 115 const std::vector<SearchRow::ColumnID>& projections, 116 const std::string& selection, 117 const std::vector<base::string16>& selection_args, 118 const std::string& sort_order); 119 120 // Runs the given update and returns the number of updated rows in 121 // |update_count| and return true, false returned if there is any error. 122 // 123 // |row| is the value need to update. 124 // |selection| is the SQL WHERE clause without 'WHERE'. 125 // |selection_args| is the arguments for WHERE clause. 126 bool UpdateSearchTerms(const SearchRow& row, 127 const std::string& selection, 128 const std::vector<base::string16>& selection_args, 129 int* update_count); 130 131 // Inserts the given valus and return the SearchTermID of inserted row. 132 SearchTermID InsertSearchTerm(const SearchRow& values); 133 134 // Deletes the matched rows and the number of deleted rows is returned in 135 // |deleted_count|. 136 // |selection| is the SQL WHERE clause without 'WHERE'. 137 // |selection_args| is the arguments for WHERE clause. 138 // 139 // if |selection| is empty all search be deleted. 140 bool DeleteSearchTerms(const std::string& selection, 141 const std::vector<base::string16>& selection_args, 142 int * deleted_count); 143 144 private: 145 friend class AndroidProviderBackendTest; 146 147 FRIEND_TEST_ALL_PREFIXES(AndroidProviderBackendTest, UpdateTables); 148 FRIEND_TEST_ALL_PREFIXES(AndroidProviderBackendTest, UpdateSearchTermTable); 149 150 typedef std::list<base::Closure> HistoryNotifications; 151 152 // The scoped transaction for AndroidProviderBackend. 153 // 154 // The new transactions are started automatically in both history and 155 // thumbnail database and could be a nesting transaction, if so, rolling back 156 // of this transaction will cause the exsting and subsequent nesting 157 // transactions failed. 158 // 159 // Commit() is used to commit the transaction, otherwise the transaction will 160 // be rolled back when the object is out of scope. This transaction could 161 // failed even the commit() is called if it is in a transaction that has been 162 // rolled back or the subsequent transaction in the same outermost 163 // transaction would be rolled back latter. 164 // 165 class ScopedTransaction { 166 public: 167 ScopedTransaction(HistoryDatabase* history_db, 168 ThumbnailDatabase* thumbnail_db); 169 ~ScopedTransaction(); 170 171 // Commit the transaction. 172 void Commit(); 173 174 private: 175 HistoryDatabase* history_db_; 176 ThumbnailDatabase* thumbnail_db_; 177 // Whether the transaction was committed. 178 bool committed_; 179 // The count of the nested transaction in history database. 180 const int history_transaction_nesting_; 181 // The count of the nested transaction in thumbnail database. 182 const int thumbnail_transaction_nesting_; 183 184 DISALLOW_COPY_AND_ASSIGN(ScopedTransaction); 185 }; 186 187 // Runs the given update and returns the number of updated rows in 188 // |update_count| and return true on success, false on error. 189 // 190 // The notifications are returned in |notifications| and the ownership of them 191 // is transfered to caller. 192 // 193 // |row| is the value to update. 194 // |selection| is the SQL WHERE clause without 'WHERE'. 195 // |selection_args| is the arguments for the WHERE clause. 196 bool UpdateHistoryAndBookmarks(const HistoryAndBookmarkRow& row, 197 const std::string& selection, 198 const std::vector<base::string16>& selection_args, 199 int* update_count, 200 HistoryNotifications* notifications); 201 202 // Inserts the given values and returns the URLID of the inserted row. 203 // The notifications are returned in |notifications| and the ownership of them 204 // is transfered to caller. 205 // The EnsureInitializedAndUpdated() will not be invoked if the 206 // |ensure_initialized_and_updated| is false. 207 AndroidURLID InsertHistoryAndBookmark(const HistoryAndBookmarkRow& values, 208 bool ensure_initialized_and_updated, 209 HistoryNotifications* notifications); 210 211 // Deletes the specified rows and returns the number of the deleted rows in 212 // |deleted_count|. 213 // |selection| is the SQL WHERE clause without 'WHERE'. 214 // |selection_args| is the arguments for the WHERE clause. 215 // 216 // The notifications are returned in |notifications| and the ownership of them 217 // is transfered to the caller. 218 // if |selection| is empty all history and bookmarks are deleted. 219 bool DeleteHistoryAndBookmarks( 220 const std::string& selection, 221 const std::vector<base::string16>& selection_args, 222 int* deleted_count, 223 HistoryNotifications* notifications); 224 225 // Deletes the matched history, returns true on success, false on error. 226 // The number of deleted row is returned in |deleted_count|. 227 // The notifications are returned in |notifications| and the ownership of them 228 // is transfered to caller. 229 // The url row is kept and the visit is reset if the matched url is 230 // bookmarked. 231 bool DeleteHistory(const std::string& selection, 232 const std::vector<base::string16>& selection_args, 233 int* deleted_count, 234 HistoryNotifications* notifications); 235 236 // Initializes and updates tables if necessary. 237 bool EnsureInitializedAndUpdated(); 238 239 // Initializes AndroidProviderBackend. 240 bool Init(); 241 242 // Update android_urls and bookmark_cache table if it is necessary. 243 bool UpdateTables(); 244 245 // Update the android_urls and bookmark_cache for visited urls. 246 bool UpdateVisitedURLs(); 247 248 // Update the android_urls for removed urls. 249 bool UpdateRemovedURLs(); 250 251 // Update the bookmark_cache table with bookmarks. 252 bool UpdateBookmarks(); 253 254 // Update the bookmark_cache table for favicon. 255 bool UpdateFavicon(); 256 257 // Update the search_term table 258 bool UpdateSearchTermTable(); 259 260 // Append the specified result columns in |projections| to the given 261 // |result_column|. 262 // To support the lazy binding, the index of favicon column will be 263 // returned if it exists, otherwise returns -1. 264 int AppendBookmarkResultColumn( 265 const std::vector<HistoryAndBookmarkRow::ColumnID>& projections, 266 std::string* result_column); 267 268 // Append the specified search result columns in |projections| to the given 269 // |result_column|. 270 void AppendSearchResultColumn( 271 const std::vector<SearchRow::ColumnID>& projections, 272 std::string* result_column); 273 274 // Runs the given query on history_bookmark virtual table and returns true if 275 // succeeds, the selected URLID and url are returned in |rows|. 276 bool GetSelectedURLs(const std::string& selection, 277 const std::vector<base::string16>& selection_args, 278 TableIDRows* rows); 279 280 // Runs the given query on search_terms table and returns true on success, 281 // The selected search term are returned in |rows|. 282 typedef std::vector<base::string16> SearchTerms; 283 bool GetSelectedSearchTerms(const std::string& selection, 284 const std::vector<base::string16>& selection_args, 285 SearchTerms* rows); 286 287 // Simulates update url by deleting the previous URL and creating a new one. 288 // Return true on success. 289 bool SimulateUpdateURL(const HistoryAndBookmarkRow& row, 290 const TableIDRows& ids, 291 HistoryNotifications* notifications); 292 293 // Query bookmark without sync the tables. It should be used after syncing 294 // tables. 295 AndroidStatement* QueryHistoryAndBookmarksInternal( 296 const std::vector<HistoryAndBookmarkRow::ColumnID>& projections, 297 const std::string& selection, 298 const std::vector<base::string16>& selection_args, 299 const std::string& sort_order); 300 301 // Delete the given urls' history, returns true on success, or false on error. 302 // If |delete_bookmarks| is set, the bookmarks are deleted as well. 303 // The notifications are returned in |notifications| and the ownership of them 304 // is transfered to caller. 305 bool DeleteHistoryInternal(const TableIDRows& urls, 306 bool delete_bookmarks, 307 HistoryNotifications* notifications); 308 309 // Broadcasts |notifications|. Broadcasting takes ownership of the 310 // notifications, so on return |notifications| will be empty. 311 void BroadcastNotifications(HistoryNotifications* notifications); 312 313 // Add the search term from the given |values|. It will add the values.url() 314 // in the urls table if it doesn't exist, insert visit in the visits table, 315 // also add keyword in keyword_search_term. 316 bool AddSearchTerm(const SearchRow& values); 317 318 // SQLHandlers for different tables. 319 scoped_ptr<SQLHandler> urls_handler_; 320 scoped_ptr<SQLHandler> visit_handler_; 321 scoped_ptr<SQLHandler> android_urls_handler_; 322 scoped_ptr<SQLHandler> favicon_handler_; 323 scoped_ptr<SQLHandler> bookmark_model_handler_; 324 325 // The vector of all handlers 326 std::vector<SQLHandler*> sql_handlers_; 327 328 // Android cache database filename. 329 const base::FilePath android_cache_db_filename_; 330 331 // The history db's connection. 332 sql::Connection* db_; 333 334 HistoryDatabase* history_db_; 335 336 ThumbnailDatabase* thumbnail_db_; 337 338 HistoryClient* history_client_; 339 340 // Whether AndroidProviderBackend has been initialized. 341 bool initialized_; 342 343 HistoryBackend::Delegate* delegate_; 344 345 DISALLOW_COPY_AND_ASSIGN(AndroidProviderBackend); 346 }; 347 348 } // namespace history 349 350 #endif // CHROME_BROWSER_HISTORY_ANDROID_ANDROID_PROVIDER_BACKEND_H_ 351
