| // Copyright 2016 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_READING_LIST_CORE_READING_LIST_MODEL_H_ |
| #define COMPONENTS_READING_LIST_CORE_READING_LIST_MODEL_H_ |
| |
| #include <memory> |
| #include <string> |
| #include <vector> |
| |
| #include "base/callback.h" |
| #include "base/observer_list.h" |
| #include "base/sequence_checker.h" |
| #include "components/reading_list/core/reading_list_entry.h" |
| #include "components/reading_list/core/reading_list_model_observer.h" |
| |
| class GURL; |
| class ReadingListModel; |
| class ScopedReadingListBatchUpdate; |
| |
| namespace syncer { |
| class ModelTypeSyncBridge; |
| } |
| |
| // The reading list model contains two list of entries: one of unread urls, the |
| // other of read ones. This object should only be accessed from one thread |
| // (Usually the main thread). The observers callbacks are also sent on the main |
| // thread. |
| class ReadingListModel { |
| public: |
| class ScopedReadingListBatchUpdate; |
| |
| // Returns true if the model finished loading. Until this returns true the |
| // reading list is not ready for use. |
| virtual bool loaded() const = 0; |
| |
| // Returns true if the model is performing batch updates right now. |
| bool IsPerformingBatchUpdates() const; |
| |
| // Returns the ModelTypeSyncBridge responsible for handling sync message. |
| virtual syncer::ModelTypeSyncBridge* GetModelTypeSyncBridge() = 0; |
| |
| // Tells model to prepare for batch updates. |
| // This method is reentrant, i.e. several batch updates may take place at the |
| // same time. |
| // Returns a scoped batch update object that should be retained while the |
| // batch update is performed. Deallocating this object will inform model that |
| // the batch update has completed. |
| std::unique_ptr<ScopedReadingListBatchUpdate> BeginBatchUpdates(); |
| |
| // Creates a batch token that will freeze the model while in scope. |
| virtual std::unique_ptr<ScopedReadingListBatchUpdate> CreateBatchToken(); |
| |
| // Returns a vector of URLs in the model. The order of the URL is not |
| // specified and can vary on successive calls. |
| virtual const std::vector<GURL> Keys() const = 0; |
| |
| // Returns the total number of entries in the model. |
| virtual size_t size() const = 0; |
| |
| // Returns the total number of unread entries in the model. |
| virtual size_t unread_size() const = 0; |
| |
| // Returns the total number of unseen entries in the model. Note: These |
| // entries are also unread so unseen_size() <= unread_size(). |
| virtual size_t unseen_size() const = 0; |
| |
| // Mark all unseen entries as unread. |
| virtual void MarkAllSeen() = 0; |
| |
| // Delete all the Reading List entries. Return true if entries where indeed |
| // deleted. |
| virtual bool DeleteAllEntries() = 0; |
| |
| // Returns the flag about unseen entries on the device. |
| // This flag is raised if some unseen items are added on this device. |
| // The flag is reset if |ResetLocalUnseenFlag| is called or if all unseen |
| // entries are removed. |
| // This is a local flag and it can have different values on different devices, |
| // even if they are synced. |
| // (unseen_size() == 0 => GetLocalUnseenFlag() == false) |
| virtual bool GetLocalUnseenFlag() const = 0; |
| |
| // Set the unseen flag to false. |
| virtual void ResetLocalUnseenFlag() = 0; |
| |
| // Returns a specific entry. Returns null if the entry does not exist. |
| virtual const ReadingListEntry* GetEntryByURL(const GURL& gurl) const = 0; |
| |
| // Returns the first unread entry. If |distilled| is true, prioritize the |
| // entries available offline. |
| virtual const ReadingListEntry* GetFirstUnreadEntry(bool distilled) const = 0; |
| |
| // Adds |url| at the top of the unread entries, and removes entries with the |
| // same |url| from everywhere else if they exist. The entry title will be a |
| // trimmed copy of |title|. |
| // The addition may be asynchronous, and the data will be available only once |
| // the observers are notified. |
| virtual const ReadingListEntry& AddEntry( |
| const GURL& url, |
| const std::string& title, |
| reading_list::EntrySource source) = 0; |
| |
| // Removes an entry. The removal may be asynchronous, and not happen |
| // immediately. |
| virtual void RemoveEntryByURL(const GURL& url) = 0; |
| |
| // If the |url| is in the reading list and entry(|url|).read != |read|, sets |
| // the read state of the URL to read. This will also update the update time of |
| // the entry. |
| virtual void SetReadStatus(const GURL& url, bool read) = 0; |
| |
| // Methods to mutate an entry. Will locate the relevant entry by URL. Does |
| // nothing if the entry is not found. |
| virtual void SetEntryTitle(const GURL& url, const std::string& title) = 0; |
| virtual void SetEntryDistilledState( |
| const GURL& url, |
| ReadingListEntry::DistillationState state) = 0; |
| |
| // Sets the Distilled info for the entry |url|. This method sets the |
| // DistillationState of the entry to PROCESSED and sets the |distilled_path| |
| // (path of the file on disk), the |distilled_url| (url of the page that |
| // was distilled, the |distillation_size| (the size of the offline data) and |
| // the |distillation_date| (date of distillation in microseconds since Jan 1st |
| // 1970. |
| virtual void SetEntryDistilledInfo(const GURL& url, |
| const base::FilePath& distilled_path, |
| const GURL& distilled_url, |
| int64_t distilation_size, |
| const base::Time& distilation_time) = 0; |
| |
| // Sets the extra info for the entry |url|. |
| virtual void SetContentSuggestionsExtra( |
| const GURL& url, |
| const reading_list::ContentSuggestionsExtra& extra) = 0; |
| // Observer registration methods. The model will remove all observers upon |
| // destruction automatically. |
| void AddObserver(ReadingListModelObserver* observer); |
| void RemoveObserver(ReadingListModelObserver* observer); |
| |
| // Helper class that is used to scope batch updates. |
| class ScopedReadingListBatchUpdate { |
| public: |
| explicit ScopedReadingListBatchUpdate(ReadingListModel* model) |
| : model_(model) {} |
| |
| virtual ~ScopedReadingListBatchUpdate(); |
| |
| private: |
| ReadingListModel* model_; |
| |
| DISALLOW_COPY_AND_ASSIGN(ScopedReadingListBatchUpdate); |
| }; |
| |
| protected: |
| ReadingListModel(); |
| virtual ~ReadingListModel(); |
| |
| // The observers. |
| base::ObserverList<ReadingListModelObserver> observers_; |
| |
| // Tells model that batch updates have completed. Called from |
| // ReadingListBatchUpdateToken dtor. |
| virtual void EndBatchUpdates(); |
| |
| // Called when model is entering batch update mode. |
| virtual void EnteringBatchUpdates(); |
| |
| // Called when model is leaving batch update mode. |
| virtual void LeavingBatchUpdates(); |
| |
| SEQUENCE_CHECKER(sequence_checker_); |
| |
| private: |
| unsigned int current_batch_updates_count_; |
| |
| DISALLOW_COPY_AND_ASSIGN(ReadingListModel); |
| }; |
| |
| #endif // COMPONENTS_READING_LIST_CORE_READING_LIST_MODEL_H_ |