[Offline pages] Detecting offline pages missing bookmarks

components/offline_pages/offline_page_model.h

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef COMPONENTS_OFFLINE_PAGES_OFFLINE_PAGE_MODEL_H_
 #define COMPONENTS_OFFLINE_PAGES_OFFLINE_PAGE_MODEL_H_
 
 #include <map>
 #include <vector>
 
@@ skipping 177 matching lines @@
   const OfflinePageItem* GetPageByBookmarkId(int64 bookmark_id) const;
 
   // Returns an offline page that is stored as |offline_url|. A nullptr is
   // returned if not found.
   const OfflinePageItem* GetPageByOfflineURL(const GURL& offline_url) const;
 
   // Returns an offline page saved for |online_url|. A nullptr is returned if
   // not found.
   const OfflinePageItem* GetPageByOnlineURL(const GURL& online_url) const;
 
-  // Checks that all of the offline pages have corresponding offline copies.
-  // If a page is discovered to be missing an offline copy, its offline page
-  // metadata will be removed and |OfflinePageDeleted| will be sent to model
-  // observers.
-  void CheckForExternalFileDeletion();
+  // Checks for and fixes the following problems with offline pages metadata:
+  // * removes pages marked for deletion when |finalize_deletion| is set to
+  // true,
+  // * removes pages that don't have a corresponding bookmark mode in the
+  // bookmarks model,
+  // * removes pages that don't have the offline archive.
+  // Metadata checks run only when the bookmark model is loaded. If a metadata
+  // check is already in progress, the method returns.
+  void CheckMetadataConsistency(bool finalize_deletion);
 
   // Methods for testing only:
   OfflinePageMetadataStore* GetStoreForTesting();
 
   bool is_loaded() const { return is_loaded_; }
 
  private:
   FRIEND_TEST_ALL_PREFIXES(OfflinePageModelTest, MarkPageForDeletion);
   FRIEND_TEST_ALL_PREFIXES(OfflinePageModelTest, BookmarkNodeChangesUrl);
 
   typedef ScopedVector<OfflinePageArchiver> PendingArchivers;
 
   // BaseBookmarkModelObserver:
+  void BookmarkModelLoaded(bookmarks::BookmarkModel* model,
+                           bool ids_reassigned) override;
+  void BookmarkModelBeingDeleted(bookmarks::BookmarkModel* model) override;
   void BookmarkModelChanged() override;
   void BookmarkNodeAdded(bookmarks::BookmarkModel* model,
                          const bookmarks::BookmarkNode* parent,
                          int index) override;
   void BookmarkNodeRemoved(bookmarks::BookmarkModel* model,
                            const bookmarks::BookmarkNode* parent,
                            int old_index,
                            const bookmarks::BookmarkNode* node,
                            const std::set<GURL>& removed_urls) override;
   void BookmarkNodeChanged(bookmarks::BookmarkModel* model,
@@ skipping 41 matching lines @@
   // Steps for marking an offline page for deletion that can be undone.
   void OnMarkPageForDeletionDone(const OfflinePageItem& offline_page_item,
                                  const DeletePageCallback& callback,
                                  bool success);
   void FinalizePageDeletion();
 
   // Steps for undoing an offline page deletion.
   void UndoPageDeletion(int64 bookmark_id);
   void OnUndoOfflinePageDone(const OfflinePageItem& offline_page, bool success);
 
-  // Callbacks for checking if offline pages are missing archive files.
+  // Callbacks and steps for checking offline page metadata consistency.
+  //
+  // Checks that all of the offline pages have corresponding offline copies.
+  // If a page is discovered to be missing an offline copy, its offline page
+  // metadata will be removed and |OfflinePageDeleted| will be sent to model
+  // observers.
+  void CheckForExternalFileDeletion(DeletePageResult);
   void OnFindPagesMissingArchiveFile(
       const std::vector<int64>* pages_missing_archive_file);
   void OnRemoveOfflinePagesMissingArchiveFileDone(
       const std::vector<int64>& bookmark_ids,
       OfflinePageModel::DeletePageResult result);
 
   // Steps for clearing all.
   void OnRemoveAllFilesDoneForClearAll(const base::Closure& callback,
                                        DeletePageResult result);
   void OnResetStoreDoneForClearAll(const base::Closure& callback, bool success);
   void OnReloadStoreDoneForClearAll(
       const base::Closure& callback,
       OfflinePageMetadataStore::LoadStatus load_status,
       const std::vector<OfflinePageItem>& offline_pages);
 
   void CacheLoadedData(const std::vector<OfflinePageItem>& offline_pages);
 
   // Persistent store for offline page metadata.
   scoped_ptr<OfflinePageMetadataStore> store_;
 
   // Location where all of the archive files will be stored.
   base::FilePath archives_dir_;
 
   // The observers.
   base::ObserverList<Observer> observers_;
 
   bool is_loaded_;
 
+  // Whether a metadata check is going on right now.
+  bool metadata_check_in_progress_;
+
   // In memory copy of the offline page metadata, keyed by bookmark IDs.
   std::map<int64, OfflinePageItem> offline_pages_;
 
   scoped_refptr<base::SequencedTaskRunner> task_runner_;
 
   // Pending archivers owned by this model.
   PendingArchivers pending_archivers_;
 
   // Delayed tasks that should be invoked after the loading is done.
   std::vector<base::Closure> delayed_tasks_;
 
+  bookmarks::BookmarkModel* bookmarks_model_;
+
   ScopedObserver<bookmarks::BookmarkModel, bookmarks::BookmarkModelObserver>
       scoped_observer_;
 
   base::WeakPtrFactory<OfflinePageModel> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(OfflinePageModel);
 };
 
 }  // namespace offline_pages
 
 #endif  // COMPONENTS_OFFLINE_PAGES_OFFLINE_PAGE_MODEL_H_