[Offline pages] Detecting missing offline copy

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 79 matching lines @@
     SUCCESS,
     CANCELLED,
     STORE_FAILURE,
   };
 
   // Observer of the OfflinePageModel.
   class Observer {
    public:
     // Invoked when the model has finished loading.
     virtual void OfflinePageModelLoaded(OfflinePageModel* model) = 0;
+    // Invoked when an offline copy related to |bookmark_id| was deleted.
+    virtual void OfflinePageDeleted(int64 bookmark_id) = 0;
 
    protected:
     virtual ~Observer() {}
   };
 
   typedef base::Callback<void(SavePageResult)> SavePageCallback;
   typedef base::Callback<void(DeletePageResult)> DeletePageCallback;
 
   // All blocking calls/disk access will happen on the provided |task_runner|.
   OfflinePageModel(
@@ skipping 39 matching lines @@
   const std::vector<OfflinePageItem> GetAllPages() const;
 
   // Gets pages that should be removed to clean up storage. Requires that the
   // model is loaded.
   const std::vector<OfflinePageItem> GetPagesToCleanUp() const;
 
   // Returns an offline page associated with a specified |bookmark_id|. nullptr
   // is returned if not found.
   const OfflinePageItem* GetPageByBookmarkId(int64 bookmark_id) const;
 
-  // Returns an offline page that is stored as |offline_url|. nullptr is
+  // 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;
 
+  // Checks that all of the offline pages have corresponding offline copies.

[jianli, 2015/10/14 22:30:23]

Can you be a bit more specific in the comment? I think offline pages already
mean to save offline copies and we should try to avoid referring to offline copy
here since it is more UI term. Can we just say "Checks all offline pages to make
sure saved files are still present, i.e. not being deleted by external
programs"?

Could you please also comment the consequence of this, like metadata being
removed and OfflinePageDeleted being fired? 

[fgorski, 2015/10/15 19:12:29]

I disagree. See line 36 in this file.
Done.

+  void CheckForExternalFileDeletion();
+
   // Methods for testing only:
   OfflinePageMetadataStore* GetStoreForTesting();
 
   bool is_loaded() const { return is_loaded_; }
 
  private:
   typedef ScopedVector<OfflinePageArchiver> PendingArchivers;
 
   // BaseBookmarkModelObserver:
   void BookmarkModelChanged() override;
@@ skipping 31 matching lines @@
       const bool* success);
   void OnRemoveOfflinePagesDone(const std::vector<int64>& bookmark_ids,
                                 const DeletePageCallback& callback,
                                 bool success);
   void InformDeletePageDone(const DeletePageCallback& callback,
                             DeletePageResult result);
 
   void OnUpdateOfflinePageDone(const OfflinePageItem& offline_page_item,
                                bool success);
 
+  // Callback for check if offline pages missing offline files.
+  void OnListPagesMissingArchiveFileDone(
+      const std::vector<int64>* pages_missing_archive_file);
+
   // Persistent store for offline page metadata.
   scoped_ptr<OfflinePageMetadataStore> store_;
 
   // The observers.
   base::ObserverList<Observer> observers_;
 
   bool is_loaded_;
 
   // In memory copy of the offline page metadata, keyed by bookmark IDs.
   std::map<int64, OfflinePageItem> offline_pages_;
@@ skipping 10 matching lines @@
       scoped_observer_;
 
   base::WeakPtrFactory<OfflinePageModel> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(OfflinePageModel);
 };
 
 }  // namespace offline_pages
 
 #endif  // COMPONENTS_OFFLINE_PAGES_OFFLINE_PAGE_MODEL_H_