Refactor Reading List Model to use URL as key.

components/reading_list/ios/reading_list_entry.h

 // 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_IOS_READING_LIST_ENTRY_H_
 #define COMPONENTS_READING_LIST_IOS_READING_LIST_ENTRY_H_
 
 #include <string>
+#include <unordered_map>
 
 #include "base/files/file_path.h"
 #include "base/macros.h"
 #include "base/time/time.h"
 #include "net/base/backoff_entry.h"
 #include "url/gurl.h"
 
 namespace reading_list {
 class ReadingListLocal;
 }
 
 namespace sync_pb {
 class ReadingListSpecifics;
 }
 
+// The hashing structure to create unorder_map<GURL, ReadingListEntry>.
+struct GURLHasher {
+  std::size_t operator()(const GURL& k) const {
+    return std::hash<std::string>()(k.spec());
+  }
+};
+
 class ReadingListEntry;
-using ReadingListEntries = std::vector<ReadingListEntry>;
+
+using ReadingListEntries =
+    std::unordered_map<GURL, ReadingListEntry, GURLHasher>;

[noyau (Ping after 24h), 2016/11/28 15:29:31]

Why is this here actually?  It is not used in this file, should it be moved
(along with the GURLHasher) to ReadingListModel?

[Olivier, 2016/11/28 15:38:10]

If I move it, I must move it in ReadingListModel, ReadingListStore,
ReadingListUnittests...

This is not impossible, but we will need to keep all of them in sync (specially
the hash function).

[Olivier, 2016/11/30 09:15:22]

Moved it (replaced by std::map as performances should be similar for the small
number of entries and it avoid having GURL hasher).

 
 // An entry in the reading list. The URL is a unique identifier for an entry, as
 // such it should not be empty and is the only thing considered when comparing
 // entries.
 class ReadingListEntry {
  public:
   ReadingListEntry(const GURL& url, const std::string& title);
   ReadingListEntry(const GURL& url,
                    const std::string& title,
                    std::unique_ptr<net::BackoffEntry> backoff);
@@ skipping 17 matching lines @@
   // The local file path for the distilled version of the page. This should only
   // be called if the state is "PROCESSED".
   const base::FilePath& DistilledPath() const;
   // The time before the next try. This is automatically increased when the
   // state is set to WILL_RETRY or ERROR from a non-error state.
   base::TimeDelta TimeUntilNextTry() const;
   // The number of time chrome failed to download this entry. This is
   // automatically increased when the state is set to WILL_RETRY or ERROR from a
   // non-error state.
   int FailedDownloadCounter() const;
+  // The read status of the entry.
+  bool IsRead() const;
 
   // The last update time of the entry. This value may be used to sort the
   // entries. The value is in microseconds since Jan 1st 1970.
   int64_t UpdateTime() const;
 
   // The creation update time of the entry. The value is in microseconds since
   // Jan 1st 1970.
   int64_t CreationTime() const;
 
   // Set the update time to now.
   void MarkEntryUpdated();
 
   // Returns a protobuf encoding the content of this ReadingListEntry for local
   // storage.
-  std::unique_ptr<reading_list::ReadingListLocal> AsReadingListLocal(
-      bool read) const;
+  std::unique_ptr<reading_list::ReadingListLocal> AsReadingListLocal() const;
 
   // Returns a protobuf encoding the content of this ReadingListEntry for sync.
-  std::unique_ptr<sync_pb::ReadingListSpecifics> AsReadingListSpecifics(
-      bool read) const;
+  std::unique_ptr<sync_pb::ReadingListSpecifics> AsReadingListSpecifics() const;
 
   // Created a ReadingListEntry from the protobuf format.
   static std::unique_ptr<ReadingListEntry> FromReadingListLocal(
       const reading_list::ReadingListLocal& pb_entry);
 
   // Created a ReadingListEntry from the protobuf format.
   static std::unique_ptr<ReadingListEntry> FromReadingListSpecifics(
       const sync_pb::ReadingListSpecifics& pb_entry);
 
   // Merge the local data from |other| to this.
@@ skipping 10 matching lines @@
   static bool CompareEntryUpdateTime(const ReadingListEntry& lhs,
                                      const ReadingListEntry& rhs);
 
   // Sets the title.
   void SetTitle(const std::string& title);
   // Sets the distilled URL and switch the state to PROCESSED and reset the time
   // until the next try.
   void SetDistilledPath(const base::FilePath& path);
   // Sets the state to one of PROCESSING, WILL_RETRY or ERROR.
   void SetDistilledState(DistillationState distilled_state);
+  // Sets the read stat of the entry. Will set the UpdateTime of the entry.
+  void SetRead(bool read);
 
  private:
   ReadingListEntry(const GURL& url,
                    const std::string& title,
+                   bool read,
                    int64_t creation_time,
                    int64_t update_time,
                    ReadingListEntry::DistillationState distilled_state,
                    const base::FilePath& distilled_path,
                    int failed_download_counter,
                    std::unique_ptr<net::BackoffEntry> backoff);
   GURL url_;
   std::string title_;
+  bool read_;
   base::FilePath distilled_path_;
   DistillationState distilled_state_;
 
   std::unique_ptr<net::BackoffEntry> backoff_;
   int failed_download_counter_;
 
   // These value are in microseconds since Jan 1st 1970. They are used for
   // sorting the entries from the database. They are kept in int64_t to avoid
   // conversion on each save/read event.
   int64_t creation_time_us_;
   int64_t update_time_us_;
 
   DISALLOW_COPY_AND_ASSIGN(ReadingListEntry);
 };
 
 #endif  // COMPONENTS_READING_LIST_IOS_READING_LIST_ENTRY_H_