DXR is a code search and navigation tool aimed at making sense of large projects. It supports full-text and regex searches as well as structural queries.

Implementation

Mercurial (1aeaa33a64f9)

VCS Links

Line Code
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375
/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

#ifndef nsNavBookmarks_h_
#define nsNavBookmarks_h_

#include "nsINavBookmarksService.h"
#include "nsNavHistory.h"
#include "nsToolkitCompsCID.h"
#include "nsCategoryCache.h"
#include "nsTHashtable.h"
#include "nsWeakReference.h"
#include "mozilla/Attributes.h"
#include "prtime.h"

class nsNavBookmarks;

namespace mozilla {
namespace places {

enum BookmarkStatementId {
  DB_FIND_REDIRECTED_BOOKMARK = 0,
  DB_GET_BOOKMARKS_FOR_URI
};

struct BookmarkData {
  int64_t id = -1;
  nsCString url;
  nsCString title;
  int32_t position = -1;
  int64_t placeId = -1;
  int64_t parentId = -1;
  int64_t grandParentId = -1;
  int32_t type = 0;
  int32_t syncStatus = nsINavBookmarksService::SYNC_STATUS_UNKNOWN;
  nsCString serviceCID;
  PRTime dateAdded = 0;
  PRTime lastModified = 0;
  nsCString guid;
  nsCString parentGuid;
};

struct ItemVisitData {
  BookmarkData bookmark;
  int64_t visitId;
  uint32_t transitionType;
  PRTime time;
};

struct ItemChangeData {
  BookmarkData bookmark;
  bool isAnnotation = false;
  bool updateLastModified = false;
  uint16_t source = nsINavBookmarksService::SOURCE_DEFAULT;
  nsCString property;
  nsCString newValue;
  nsCString oldValue;
};

struct TombstoneData {
  nsCString guid;
  PRTime dateRemoved;
};

typedef void (nsNavBookmarks::*ItemVisitMethod)(const ItemVisitData&);
typedef void (nsNavBookmarks::*ItemChangeMethod)(const ItemChangeData&);

enum BookmarkDate { LAST_MODIFIED };

}  // namespace places
}  // namespace mozilla

class nsNavBookmarks final : public nsINavBookmarksService,
                             public nsINavHistoryObserver,
                             public nsIObserver,
                             public nsSupportsWeakReference {
 public:
  NS_DECL_ISUPPORTS
  NS_DECL_NSINAVBOOKMARKSSERVICE
  NS_DECL_NSINAVHISTORYOBSERVER
  NS_DECL_NSIOBSERVER

  nsNavBookmarks();

  /**
   * Obtains the service's object.
   */
  static already_AddRefed<nsNavBookmarks> GetSingleton();

  /**
   * Initializes the service's object.  This should only be called once.
   */
  nsresult Init();

  static nsNavBookmarks* GetBookmarksService() {
    if (!gBookmarksService) {
      nsCOMPtr<nsINavBookmarksService> serv =
          do_GetService(NS_NAVBOOKMARKSSERVICE_CONTRACTID);
      NS_ENSURE_TRUE(serv, nullptr);
      NS_ASSERTION(gBookmarksService,
                   "Should have static instance pointer now");
    }
    return gBookmarksService;
  }

  typedef mozilla::places::BookmarkData BookmarkData;
  typedef mozilla::places::ItemVisitData ItemVisitData;
  typedef mozilla::places::ItemChangeData ItemChangeData;
  typedef mozilla::places::BookmarkStatementId BookmarkStatementId;

  nsresult OnVisit(nsIURI* aURI, int64_t aVisitId, PRTime aTime,
                   int64_t aSessionId, int64_t aReferringId,
                   uint32_t aTransitionType, const nsACString& aGUID,
                   bool aHidden, uint32_t aVisitCount, uint32_t aTyped,
                   const nsAString& aLastKnownTitle);

  nsresult ResultNodeForContainer(int64_t aID,
                                  nsNavHistoryQueryOptions* aOptions,
                                  nsNavHistoryResultNode** aNode);

  // Find all the children of a folder, using the given query and options.
  // For each child, a ResultNode is created and added to |children|.
  // The results are ordered by folder position.
  nsresult QueryFolderChildren(int64_t aFolderId,
                               nsNavHistoryQueryOptions* aOptions,
                               nsCOMArray<nsNavHistoryResultNode>* children);

  /**
   * Turns aRow into a node and appends it to aChildren if it is appropriate to
   * do so.
   *
   * @param aRow
   *        A Storage statement (in the case of synchronous execution) or row of
   *        a result set (in the case of asynchronous execution).
   * @param aOptions
   *        The options of the parent folder node. These are the options used
   *        to fill the parent node.
   * @param aChildren
   *        The children of the parent folder node.
   * @param aCurrentIndex
   *        The index of aRow within the results.  When called on the first row,
   *        this should be set to -1.
   */
  nsresult ProcessFolderNodeRow(mozIStorageValueArray* aRow,
                                nsNavHistoryQueryOptions* aOptions,
                                nsCOMArray<nsNavHistoryResultNode>* aChildren,
                                int32_t& aCurrentIndex);

  /**
   * The async version of QueryFolderChildren.
   *
   * @param aNode
   *        The folder node that will receive the children.
   * @param _pendingStmt
   *        The Storage pending statement that will be used to control async
   *        execution.
   */
  nsresult QueryFolderChildrenAsync(nsNavHistoryFolderResultNode* aNode,
                                    mozIStoragePendingStatement** _pendingStmt);

  /**
   * Fetches information about the specified id from the database.
   *
   * @param aItemId
   *        Id of the item to fetch information for.
   * @param aBookmark
   *        BookmarkData to store the information.
   */
  nsresult FetchItemInfo(int64_t aItemId, BookmarkData& _bookmark);

  /**
   * Notifies that a bookmark has been visited.
   *
   * @param aItemId
   *        The visited item id.
   * @param aData
   *        Details about the new visit.
   */
  void NotifyItemVisited(const ItemVisitData& aData);

  /**
   * Notifies that a bookmark has changed.
   *
   * @param aItemId
   *        The changed item id.
   * @param aData
   *        Details about the change.
   */
  void NotifyItemChanged(const ItemChangeData& aData);

  /**
   * Recursively builds an array of descendant folders inside a given folder.
   *
   * @param aFolderId
   *        The folder to fetch descendants from.
   * @param aDescendantFoldersArray
   *        Output array to put descendant folders id.
   */
  nsresult GetDescendantFolders(int64_t aFolderId,
                                nsTArray<int64_t>& aDescendantFoldersArray);

  static const int32_t kGetChildrenIndex_Guid;
  static const int32_t kGetChildrenIndex_Position;
  static const int32_t kGetChildrenIndex_Type;
  static const int32_t kGetChildrenIndex_PlaceID;
  static const int32_t kGetChildrenIndex_SyncStatus;

  static mozilla::Atomic<int64_t> sLastInsertedItemId;
  static void StoreLastInsertedId(const nsACString& aTable,
                                  const int64_t aLastInsertedId);

 private:
  static nsNavBookmarks* gBookmarksService;

  ~nsNavBookmarks();

  /**
   * Checks whether or not aFolderId points to a live bookmark.
   *
   * @param aFolderId
   *        the item-id of the folder to check.
   * @return true if aFolderId points to live bookmarks, false otherwise.
   */
  bool IsLivemark(int64_t aFolderId);

  /**
   * Locates the root items in the bookmarks folder hierarchy assigning folder
   * ids to the root properties that are exposed through the service interface.
   */
  nsresult EnsureRoots();

  nsresult AdjustIndices(int64_t aFolder, int32_t aStartIndex,
                         int32_t aEndIndex, int32_t aDelta);

  nsresult AdjustSeparatorsSyncCounter(int64_t aFolderId, int32_t aStartIndex,
                                       int64_t aSyncChangeDelta);

  /**
   * Fetches properties of a folder.
   *
   * @param aFolderId
   *        Folder to count children for.
   * @param _folderCount
   *        Number of children in the folder.
   * @param _guid
   *        Unique id of the folder.
   * @param _parentId
   *        Id of the parent of the folder.
   *
   * @throws If folder does not exist.
   */
  nsresult FetchFolderInfo(int64_t aFolderId, int32_t* _folderCount,
                           nsACString& _guid, int64_t* _parentId);

  nsresult AddSyncChangesForBookmarksWithURL(const nsACString& aURL,
                                             int64_t aSyncChangeDelta);

  // Bumps the change counter for all bookmarks with |aURI|. This is used to
  // update tagged bookmarks when adding or changing a tag entry.
  nsresult AddSyncChangesForBookmarksWithURI(nsIURI* aURI,
                                             int64_t aSyncChangeDelta);

  // Bumps the change counter for all bookmarked URLs within |aFolderId|. This
  // is used to update tagged bookmarks when changing or removing a tag folder.
  nsresult AddSyncChangesForBookmarksInFolder(int64_t aFolderId,
                                              int64_t aSyncChangeDelta);

  // Inserts a tombstone for a removed synced item.
  nsresult InsertTombstone(const BookmarkData& aBookmark);

  // Inserts tombstones for removed synced items.
  nsresult InsertTombstones(const nsTArray<TombstoneData>& aTombstones);

  // Removes a stale synced bookmark tombstone.
  nsresult RemoveTombstone(const nsACString& aGUID);

  nsresult SetItemTitleInternal(BookmarkData& aBookmark,
                                const nsACString& aTitle,
                                int64_t aSyncChangeDelta);

  /**
   * This is an handle to the Places database.
   */
  RefPtr<mozilla::places::Database> mDB;

  nsMaybeWeakPtrArray<nsINavBookmarkObserver> mObservers;

  int64_t TagsRootId() {
    nsresult rv = EnsureRoots();
    NS_ENSURE_SUCCESS(rv, -1);
    return mTagsRoot;
  }

  // These are lazy loaded, so never access them directly, always use the
  // XPIDL getters or TagsRootId().
  int64_t mRoot;
  int64_t mMenuRoot;
  int64_t mTagsRoot;
  int64_t mUnfiledRoot;
  int64_t mToolbarRoot;
  int64_t mMobileRoot;

  inline bool IsRoot(int64_t aFolderId) {
    return aFolderId == mRoot || aFolderId == mMenuRoot ||
           aFolderId == mTagsRoot || aFolderId == mUnfiledRoot ||
           aFolderId == mToolbarRoot || aFolderId == mMobileRoot;
  }

  nsresult SetItemDateInternal(enum mozilla::places::BookmarkDate aDateType,
                               int64_t aSyncChangeDelta, int64_t aItemId,
                               PRTime aValue);

  nsresult RemoveFolderChildren(int64_t aFolderId, uint16_t aSource);

  // Recursive method to build an array of folder's children
  nsresult GetDescendantChildren(int64_t aFolderId,
                                 const nsACString& aFolderGuid,
                                 int64_t aGrandParentId,
                                 nsTArray<BookmarkData>& aFolderChildrenArray);

  enum ItemType {
    BOOKMARK = TYPE_BOOKMARK,
    FOLDER = TYPE_FOLDER,
    SEPARATOR = TYPE_SEPARATOR,
  };

  /**
   * Helper to insert a bookmark in the database.
   *
   *  @param aItemId
   *         The itemId to insert, pass -1 to generate a new one.
   *  @param aPlaceId
   *         The placeId to which this bookmark refers to, pass nullptr for
   *         items that don't refer to an URI (eg. folders, separators, ...).
   *  @param aItemType
   *         The type of the new bookmark, see TYPE_* constants.
   *  @param aParentId
   *         The itemId of the parent folder.
   *  @param aIndex
   *         The position inside the parent folder.
   *  @param aTitle
   *         The title for the new bookmark.
   *         Pass a void string to set a NULL title.
   *  @param aDateAdded
   *         The date for the insertion.
   *  @param [optional] aLastModified
   *         The last modified date for the insertion.
   *         It defaults to aDateAdded.
   *
   *  @return The new item id that has been inserted.
   *
   *  @note This will also update last modified date of the parent folder.
   */
  nsresult InsertBookmarkInDB(int64_t aPlaceId, enum ItemType aItemType,
                              int64_t aParentId, int32_t aIndex,
                              const nsACString& aTitle, PRTime aDateAdded,
                              PRTime aLastModified,
                              const nsACString& aParentGuid,
                              int64_t aGrandParentId, nsIURI* aURI,
                              uint16_t aSource, int64_t* _itemId,
                              nsACString& _guid);

  nsresult GetBookmarksForURI(nsIURI* aURI, nsTArray<BookmarkData>& _bookmarks);

  // Used to enable and disable the observer notifications.
  bool mCanNotify;

  // Tracks whether we are in batch mode.
  // Note: this is only tracking bookmarks batches, not history ones.
  bool mBatching;
};

#endif  // nsNavBookmarks_h_