Refactor Reading List Model to use URL as key.

ios/chrome/browser/reading_list/reading_list_model_impl.cc

 // 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.
 
 #include "ios/chrome/browser/reading_list/reading_list_model_impl.h"
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
 #include "base/strings/string_util.h"
 #include "components/prefs/pref_service.h"
 #include "ios/chrome/browser/reading_list/reading_list_model_storage.h"
 #include "ios/chrome/browser/reading_list/reading_list_pref_names.h"
 #include "url/gurl.h"
 
+ReadingListModelImpl::Cache::Cache()
+    : read_entries(std::vector<GURL>()),
+      unread_entries(std::vector<GURL>()),
+      dirty(false) {}
+
+ReadingListModelImpl::Cache::~Cache() {}
+
 ReadingListModelImpl::ReadingListModelImpl()
     : ReadingListModelImpl(nullptr, nullptr) {}
 
 ReadingListModelImpl::ReadingListModelImpl(
     std::unique_ptr<ReadingListModelStorage> storage,
     PrefService* pref_service)
-    : pref_service_(pref_service),
+    : unread_entry_count_(0),
+      read_entry_count_(0),

[gambard, 2016/11/23 12:11:07]

I would have only kept the unread entry count. As you have both we can probably
keep it for tests and things like that, but it is not used.

[Olivier, 2016/11/28 14:54:14]

I will keep them at the moment, but I may remove one of them in the cleaning CL.

+      cache_(base::MakeUnique<struct Cache>()),
+      pref_service_(pref_service),
       has_unseen_(false),
       loaded_(false),
       weak_ptr_factory_(this) {
   DCHECK(CalledOnValidThread());
   if (storage) {
     storage_layer_ = std::move(storage);
     storage_layer_->SetReadingListModel(this, this);
   } else {
     loaded_ = true;
-    read_ = base::MakeUnique<ReadingListEntries>();
-    unread_ = base::MakeUnique<ReadingListEntries>();
+    entries_ = base::MakeUnique<ReadingListEntries>();
+    cache_->dirty = true;
   }
   has_unseen_ = GetPersistentHasUnseen();
 }
 
 ReadingListModelImpl::~ReadingListModelImpl() {}
 
 void ReadingListModelImpl::StoreLoaded(
-    std::unique_ptr<ReadingListEntries> unread,
-    std::unique_ptr<ReadingListEntries> read) {
+    std::unique_ptr<ReadingListEntries> entries) {
   DCHECK(CalledOnValidThread());
-  read_ = std::move(read);
-  unread_ = std::move(unread);
+  entries_ = std::move(entries);
+  cache_->dirty = true;
+  for (auto& iterator : *entries_) {
+    if (iterator.second.IsRead()) {
+      read_entry_count_++;
+    } else {
+      unread_entry_count_++;
+    }
+  }
+  DCHECK(read_entry_count_ + unread_entry_count_ == entries_->size());
   loaded_ = true;
-  SortEntries();
   for (auto& observer : observers_)
     observer.ReadingListModelLoaded(this);
 }
 
 void ReadingListModelImpl::Shutdown() {
   DCHECK(CalledOnValidThread());
   for (auto& observer : observers_)
     observer.ReadingListModelBeingDeleted(this);
   loaded_ = false;
 }
 
 bool ReadingListModelImpl::loaded() const {
   DCHECK(CalledOnValidThread());
   return loaded_;
 }
 
+size_t ReadingListModelImpl::size() const {
+  DCHECK(CalledOnValidThread());
+  DCHECK(read_entry_count_ + unread_entry_count_ == entries_->size());
+  if (!loaded())
+    return 0;
+  return unread_entry_count_ + read_entry_count_;

[gambard, 2016/11/23 12:11:07]

entries_->size() is probably shorter and you are using it just above.

[Olivier, 2016/11/28 14:54:14]

Done.

+}
+
 size_t ReadingListModelImpl::unread_size() const {
   DCHECK(CalledOnValidThread());
+  DCHECK(read_entry_count_ + unread_entry_count_ == entries_->size());
   if (!loaded())
     return 0;
-  return unread_->size();
+  return unread_entry_count_;
 }
 
 size_t ReadingListModelImpl::read_size() const {
   DCHECK(CalledOnValidThread());
+  DCHECK(read_entry_count_ + unread_entry_count_ == entries_->size());
   if (!loaded())
     return 0;
-  return read_->size();
+  return read_entry_count_;
 }
 
 bool ReadingListModelImpl::HasUnseenEntries() const {
   DCHECK(CalledOnValidThread());
   if (!loaded())
     return false;
   return unread_size() && has_unseen_;
 }
 
 void ReadingListModelImpl::ResetUnseenEntries() {
   DCHECK(CalledOnValidThread());
   DCHECK(loaded());
   has_unseen_ = false;
   if (!IsPerformingBatchUpdates())
     SetPersistentHasUnseen(false);
 }
 
-const ReadingListEntry& ReadingListModelImpl::GetUnreadEntryAtIndex(
+const ReadingListEntry* ReadingListModelImpl::GetEntryFromURL(

[gambard, 2016/11/23 12:11:06]

I am not sure this method makes sense.
The order "unread by date then read by date" seems weird to me. I would only
keep the GetUnread/ReadEntryAt(), then remove them completely once it is moved
to ReadingListViewController.

[Olivier, 2016/11/28 14:54:14]

I guess this applies to GetEntryAt. Removed.

+    const GURL& gurl) const {
+  DCHECK(CalledOnValidThread());
+  DCHECK(loaded());
+  return GetMutableEntryFromURL(gurl);
+}
+
+const ReadingListEntry* ReadingListModelImpl::GetEntryAt(size_t index) const {

[gambard, 2016/11/23 12:11:07]

Remove this method. You only need the old method for downstream compatibility.
When changing the downstream code you can move those methods there with the
cache.

[Olivier, 2016/11/28 14:54:14]

Done.

+  DCHECK(CalledOnValidThread());
+  DCHECK(loaded());
+  if (index >= read_entry_count_ + unread_entry_count_) {
+    return nullptr;
+  }
+  if (cache_->dirty) {
+    RebuildIndex();
+  }
+  if (index < unread_entry_count_) {
+    return GetEntryFromURL(cache_->unread_entries[index]);
+  } else {
+    return GetEntryFromURL(cache_->read_entries[index - unread_entry_count_]);
+  }
+}
+
+const ReadingListEntry* ReadingListModelImpl::GetReadEntryAt(

[gambard, 2016/11/23 12:11:06]

Same as above.

[Olivier, 2016/11/28 14:54:14]

Done.

     size_t index) const {
   DCHECK(CalledOnValidThread());
   DCHECK(loaded());
-  return unread_->at(index);
+  return GetEntryAt(unread_entry_count_ + index);
 }
 
-const ReadingListEntry& ReadingListModelImpl::GetReadEntryAtIndex(
+const ReadingListEntry* ReadingListModelImpl::GetUnreadEntryAt(
     size_t index) const {
   DCHECK(CalledOnValidThread());
   DCHECK(loaded());
-  return read_->at(index);
+  return GetEntryAt(index);
 }
 
-const ReadingListEntry* ReadingListModelImpl::GetEntryFromURL(
-    const GURL& gurl,
-    bool* read) const {
+void ReadingListModelImpl::RebuildIndex() const {
   DCHECK(CalledOnValidThread());
   DCHECK(loaded());
-  return GetMutableEntryFromURL(gurl, read);
+  if (!cache_->dirty) {
+    return;
+  }
+  cache_->dirty = false;
+  cache_->read_entries.clear();
+  cache_->unread_entries.clear();
+  for (auto& iterator : *entries_) {
+    if (iterator.second.IsRead()) {
+      cache_->read_entries.push_back(iterator.first);
+    } else {
+      cache_->unread_entries.push_back(iterator.first);
+    }
+  }
+  DCHECK(read_entry_count_ == cache_->read_entries.size());
+  DCHECK(unread_entry_count_ == cache_->unread_entries.size());
+  std::sort(cache_->read_entries.begin(), cache_->read_entries.end(),
+            [this](const GURL& left_url, const GURL& right_url) {
+              return this->entries_->at(left_url).UpdateTime() >
+                     this->entries_->at(right_url).UpdateTime();
+            });
+  std::sort(cache_->unread_entries.begin(), cache_->unread_entries.end(),
+            [this](const GURL& left_url, const GURL& right_url) {
+              return this->entries_->at(left_url).UpdateTime() >
+                     this->entries_->at(right_url).UpdateTime();
+            });
 }
 
 ReadingListEntry* ReadingListModelImpl::GetMutableEntryFromURL(
-    const GURL& gurl,
-    bool* read) const {
+    const GURL& gurl) const {
   DCHECK(CalledOnValidThread());
   DCHECK(loaded());
-  bool is_read;
-  ReadingListEntry entry(gurl, std::string());
-  auto it = std::find(read_->begin(), read_->end(), entry);
-  is_read = true;
-  if (it == read_->end()) {
-    it = std::find(unread_->begin(), unread_->end(), entry);
-    is_read = false;
-    if (it == unread_->end())
-      return nullptr;
-  }
-  if (read) {
-    *read = is_read;
-  }
-  return &(*it);
+  if (!entries_->count(gurl))

[jif-google, 2016/11/22 18:21:45]

instead of calling |->count| and |->at|, just do a single |->find|, and check
that the returned iterator is OK.

[Olivier, 2016/11/28 14:54:14]

Done.

+    return nullptr;
+  return &entries_->at(gurl);
 }
 
 bool ReadingListModelImpl::CallbackEntryURL(
     const GURL& url,
     base::Callback<void(const ReadingListEntry&)> callback) const {
   DCHECK(CalledOnValidThread());
   DCHECK(loaded());
-  const ReadingListEntry* entry = GetMutableEntryFromURL(url, nullptr);
+  const ReadingListEntry* entry = GetMutableEntryFromURL(url);
   if (entry) {
     callback.Run(*entry);
     return true;
   }
   return false;
 }
 
-void ReadingListModelImpl::MoveEntryFrom(ReadingListEntries* entries,
-                                         const ReadingListEntry& entry,
-                                         bool read) {
-  auto result = std::find(entries->begin(), entries->end(), entry);
-  DCHECK(result != entries->end());
-  int index = std::distance(entries->begin(), result);
-  for (auto& observer : observers_)
-    observer.ReadingListWillMoveEntry(this, index, read);
-  entries->erase(result);
-}
-
-void ReadingListModelImpl::SyncAddEntry(std::unique_ptr<ReadingListEntry> entry,
-                                        bool read) {
+void ReadingListModelImpl::SyncAddEntry(
+    std::unique_ptr<ReadingListEntry> entry) {
   DCHECK(CalledOnValidThread());
   DCHECK(loaded());
   // entry must not already exist.
-  DCHECK(GetMutableEntryFromURL(entry->URL(), nullptr) == nullptr);
-  if (read) {
-    for (auto& observer : observers_)
-      observer.ReadingListWillAddReadEntry(this, *entry);
-    read_->insert(read_->begin(), std::move(*entry));
+  DCHECK(GetMutableEntryFromURL(entry->URL()) == nullptr);
+  for (auto& observer : observers_)
+    observer.ReadingListWillAddEntry(this, *entry);
+  if (entry->IsRead()) {
+    read_entry_count_++;
   } else {
-    for (auto& observer : observers_)
-      observer.ReadingListWillAddUnreadEntry(this, *entry);
-    has_unseen_ = true;
+    unread_entry_count_++;
     SetPersistentHasUnseen(true);
-    unread_->insert(unread_->begin(), std::move(*entry));
   }
+  entries_->insert(std::make_pair(entry->URL(), std::move(*entry)));

[jif-google, 2016/11/22 18:21:45]

this is pretty much:
some_func(a, std::move(a));
you like to live dangerously.

How about:

auto& entryInMap = entries_[entry->URL()];
entryInMap = std::move(*entry);

Even better:
auto& entryInMap = entries_[entry->URL()];
entryInMap = std::move(entry.release());

[Olivier, 2016/11/28 14:54:14]

Done.
You cannot use operator[] as there is no default constructor for
ReadingListEntry.

+  cache_->dirty = true;
   for (auto& observer : observers_)
     observer.ReadingListDidApplyChanges(this);
 }
 
 ReadingListEntry* ReadingListModelImpl::SyncMergeEntry(
-    std::unique_ptr<ReadingListEntry> entry,
-    bool read) {
+    std::unique_ptr<ReadingListEntry> entry) {
   DCHECK(CalledOnValidThread());
   DCHECK(loaded());
-  bool is_existing_entry_read;
-  ReadingListEntry* existing_entry =
-      GetMutableEntryFromURL(entry->URL(), &is_existing_entry_read);
-
+  ReadingListEntry* existing_entry = GetMutableEntryFromURL(entry->URL());
   DCHECK(existing_entry);
   DCHECK(existing_entry->UpdateTime() < entry->UpdateTime());
 
+  GURL url = entry->URL();

[jif-google, 2016/11/22 18:21:45]

const GURL & url = ...

[Olivier, 2016/11/28 14:54:14]

I need the url adter the std::move, so I make a copy.

+
+  for (auto& observer : observers_)
+    observer.ReadingListWillMoveEntry(this, url);
+
+  if (existing_entry->IsRead()) {
+    read_entry_count_--;
+  } else {
+    unread_entry_count_--;
+  }
   // Merge local data in new entry.
   entry->MergeLocalStateFrom(*existing_entry);
 
-  if (is_existing_entry_read) {
-    MoveEntryFrom(read_.get(), *existing_entry, true);
+  entries_->find(url)->second = std::move(*entry);
+  cache_->dirty = true;
+
+  existing_entry = GetMutableEntryFromURL(entry->URL());
+  if (existing_entry->IsRead()) {
+    read_entry_count_++;
   } else {
-    MoveEntryFrom(unread_.get(), *existing_entry, false);
-  }
-
-  ReadingListEntries::iterator added_iterator;
-  if (read) {
-    read_->push_back(std::move(*entry));
-    added_iterator = read_->end() - 1;
-  } else {
-    unread_->push_back(std::move(*entry));
-    added_iterator = unread_->end() - 1;
+    unread_entry_count_++;
   }
   for (auto& observer : observers_)
     observer.ReadingListDidApplyChanges(this);
-
-  ReadingListEntry& merged_entry = *added_iterator;
-  return &merged_entry;
+  return existing_entry;
 }
 
 void ReadingListModelImpl::SyncRemoveEntry(const GURL& url) {
   RemoveEntryByURLImpl(url, true);
 }
 
 void ReadingListModelImpl::RemoveEntryByURL(const GURL& url) {
   RemoveEntryByURLImpl(url, false);
 }
 
 void ReadingListModelImpl::RemoveEntryByURLImpl(const GURL& url,
                                                 bool from_sync) {
   DCHECK(CalledOnValidThread());
   DCHECK(loaded());
-  const ReadingListEntry entry(url, std::string());
+  if (!entries_->count(url))
+    return;
 
-  auto result = std::find(unread_->begin(), unread_->end(), entry);
-  if (result != unread_->end()) {
-    for (auto& observer : observers_)
-      observer.ReadingListWillRemoveUnreadEntry(
-          this, std::distance(unread_->begin(), result));
-
-    if (storage_layer_ && !from_sync) {
-      storage_layer_->RemoveEntry(*result);
-    }
-    unread_->erase(result);
-
-    for (auto& observer : observers_)
-      observer.ReadingListDidApplyChanges(this);
-    return;
+  for (auto& observer : observers_)
+    observer.ReadingListWillRemoveEntry(this, url);
+  const ReadingListEntry* entry = GetEntryFromURL(url);
+  if (storage_layer_ && !from_sync) {
+    storage_layer_->RemoveEntry(entry);
   }
-
-  result = std::find(read_->begin(), read_->end(), entry);
-  if (result != read_->end()) {
-    for (auto& observer : observers_)
-      observer.ReadingListWillRemoveReadEntry(
-          this, std::distance(read_->begin(), result));
-    if (storage_layer_ && !from_sync) {
-      storage_layer_->RemoveEntry(*result);
-    }
-    read_->erase(result);
-
-    for (auto& observer : observers_)
-      observer.ReadingListDidApplyChanges(this);
-    return;
+  if (entry->IsRead()) {
+    read_entry_count_--;
+  } else {
+    unread_entry_count_--;
   }
+  entries_->erase(url);
+  cache_->dirty = true;
+  for (auto& observer : observers_)
+    observer.ReadingListDidApplyChanges(this);
 }
 
 const ReadingListEntry& ReadingListModelImpl::AddEntry(
     const GURL& url,
     const std::string& title) {
   DCHECK(CalledOnValidThread());
   DCHECK(loaded());
   RemoveEntryByURL(url);

[jif-google, 2016/11/22 18:21:45]

Wouldn't it make more sense to call "willUpdateEntry" on the observers if a
reading list entry for that URL already existed.

[Olivier, 2016/11/28 14:54:14]

The current workflow is to remove the entry, then readd it (meaning redownload
the offline version).

 
   std::string trimmedTitle(title);
   base::TrimWhitespaceASCII(trimmedTitle, base::TRIM_ALL, &trimmedTitle);
 
   ReadingListEntry entry(url, trimmedTitle);
   for (auto& observer : observers_)
-    observer.ReadingListWillAddUnreadEntry(this, entry);
+    observer.ReadingListWillAddEntry(this, entry);
   has_unseen_ = true;
   SetPersistentHasUnseen(true);
+  entries_->insert(std::make_pair(url, std::move(entry)));
+  unread_entry_count_++;
   if (storage_layer_) {
-    storage_layer_->SaveEntry(entry, false);
+    storage_layer_->SaveEntry(GetEntryFromURL(url));
   }
-  unread_->insert(unread_->begin(), std::move(entry));
+  cache_->dirty = true;
 
   for (auto& observer : observers_)
     observer.ReadingListDidApplyChanges(this);
-  return *unread_->begin();
+  return entries_->at(url);
 }
 
-void ReadingListModelImpl::MarkUnreadByURL(const GURL& url) {
+void ReadingListModelImpl::SetReadStatus(const GURL& url, bool read) {
   DCHECK(CalledOnValidThread());
   DCHECK(loaded());
-  ReadingListEntry entry(url, std::string());
-  auto result = std::find(read_->begin(), read_->end(), entry);
-  if (result == read_->end())
+  if (!entries_->count(url)) {
     return;
-
+  }
+  ReadingListEntry& entry = entries_->at(url);
+  if (entry.IsRead() == read) {
+    return;
+  }
   for (ReadingListModelObserver& observer : observers_) {
-    observer.ReadingListWillMoveEntry(
-        this, std::distance(read_->begin(), result), true);
+    observer.ReadingListWillMoveEntry(this, url);
   }
-
-  result->MarkEntryUpdated();
+  if (read) {
+    read_entry_count_++;
+    unread_entry_count_--;
+  } else {
+    unread_entry_count_++;
+    read_entry_count_--;
+  }
+  entry.SetRead(read);
+  entry.MarkEntryUpdated();
+  cache_->dirty = true;
   if (storage_layer_) {
-    storage_layer_->SaveEntry(*result, false);
+    storage_layer_->SaveEntry(GetEntryFromURL(url));
   }
-
-  unread_->insert(unread_->begin(), std::move(*result));
-  read_->erase(result);
-
   for (ReadingListModelObserver& observer : observers_) {
     observer.ReadingListDidApplyChanges(this);
   }
 }
 
-void ReadingListModelImpl::MarkReadByURL(const GURL& url) {
-  DCHECK(CalledOnValidThread());
-  DCHECK(loaded());
-  ReadingListEntry entry(url, std::string());
-  auto result = std::find(unread_->begin(), unread_->end(), entry);
-  if (result == unread_->end())
-    return;
-
-  for (auto& observer : observers_)
-    observer.ReadingListWillMoveEntry(
-        this, std::distance(unread_->begin(), result), false);
-
-  result->MarkEntryUpdated();
-  if (storage_layer_) {
-    storage_layer_->SaveEntry(*result, true);
-  }
-
-  read_->insert(read_->begin(), std::move(*result));
-  unread_->erase(result);
-
-  for (auto& observer : observers_)
-    observer.ReadingListDidApplyChanges(this);
-}
-
 void ReadingListModelImpl::SetEntryTitle(const GURL& url,
                                          const std::string& title) {
   DCHECK(CalledOnValidThread());
   DCHECK(loaded());
-  const ReadingListEntry entry(url, std::string());
-
-  auto result = std::find(unread_->begin(), unread_->end(), entry);
-  if (result != unread_->end()) {
-    for (auto& observer : observers_)
-      observer.ReadingListWillUpdateUnreadEntry(
-          this, std::distance(unread_->begin(), result));
-    result->SetTitle(title);
-
-    if (storage_layer_) {
-      storage_layer_->SaveEntry(*result, false);
-    }
-    for (auto& observer : observers_)
-      observer.ReadingListDidApplyChanges(this);
+  if (!entries_->count(url)) {
+    return;
+  }
+  ReadingListEntry& entry = entries_->at(url);
+  if (entry.Title() == title) {
     return;
   }
 
-  result = std::find(read_->begin(), read_->end(), entry);
-  if (result != read_->end()) {
-    for (auto& observer : observers_)
-      observer.ReadingListWillUpdateReadEntry(
-          this, std::distance(read_->begin(), result));
-    result->SetTitle(title);
-    if (storage_layer_) {
-      storage_layer_->SaveEntry(*result, true);
-    }
-    for (auto& observer : observers_)
-      observer.ReadingListDidApplyChanges(this);
-    return;
+  for (ReadingListModelObserver& observer : observers_) {
+    observer.ReadingListWillUpdateEntry(this, url);
+  }
+  entry.SetTitle(title);
+  if (storage_layer_) {
+    storage_layer_->SaveEntry(GetEntryFromURL(url));
+  }
+  for (ReadingListModelObserver& observer : observers_) {
+    observer.ReadingListDidApplyChanges(this);
   }
 }
 
 void ReadingListModelImpl::SetEntryDistilledPath(
     const GURL& url,
     const base::FilePath& distilled_path) {
   DCHECK(CalledOnValidThread());
   DCHECK(loaded());
-  const ReadingListEntry entry(url, std::string());
-
-  auto result = std::find(unread_->begin(), unread_->end(), entry);
-  if (result != unread_->end()) {
-    for (auto& observer : observers_)
-      observer.ReadingListWillUpdateUnreadEntry(
-          this, std::distance(unread_->begin(), result));
-    result->SetDistilledPath(distilled_path);
-    if (storage_layer_) {
-      storage_layer_->SaveEntry(*result, false);
-    }
-    for (auto& observer : observers_)
-      observer.ReadingListDidApplyChanges(this);
+  if (!entries_->count(url)) {
+    return;
+  }
+  ReadingListEntry& entry = entries_->at(url);
+  if (entry.DistilledState() == ReadingListEntry::PROCESSED &&
+      entry.DistilledPath() == distilled_path) {
     return;
   }
 
-  result = std::find(read_->begin(), read_->end(), entry);
-  if (result != read_->end()) {
-    for (auto& observer : observers_)
-      observer.ReadingListWillUpdateReadEntry(
-          this, std::distance(read_->begin(), result));
-    result->SetDistilledPath(distilled_path);
-    if (storage_layer_) {
-      storage_layer_->SaveEntry(*result, true);
-    }
-    for (auto& observer : observers_)
-      observer.ReadingListDidApplyChanges(this);
-    return;
+  for (ReadingListModelObserver& observer : observers_) {
+    observer.ReadingListWillUpdateEntry(this, url);
+  }
+  entry.SetDistilledPath(distilled_path);
+  if (storage_layer_) {
+    storage_layer_->SaveEntry(GetEntryFromURL(url));
+  }
+  for (ReadingListModelObserver& observer : observers_) {
+    observer.ReadingListDidApplyChanges(this);
   }
 }
 
 void ReadingListModelImpl::SetEntryDistilledState(
     const GURL& url,
     ReadingListEntry::DistillationState state) {
   DCHECK(CalledOnValidThread());
   DCHECK(loaded());
-  const ReadingListEntry entry(url, std::string());
-
-  auto result = std::find(unread_->begin(), unread_->end(), entry);
-  if (result != unread_->end()) {
-    for (auto& observer : observers_)
-      observer.ReadingListWillUpdateUnreadEntry(
-          this, std::distance(unread_->begin(), result));
-    result->SetDistilledState(state);
-    if (storage_layer_) {
-      storage_layer_->SaveEntry(*result, false);
-    }
-    for (auto& observer : observers_)
-      observer.ReadingListDidApplyChanges(this);
+  if (!entries_->count(url)) {
+    return;
+  }
+  ReadingListEntry& entry = entries_->at(url);
+  if (entry.DistilledState() == state) {
     return;
   }
 
-  result = std::find(read_->begin(), read_->end(), entry);
-  if (result != read_->end()) {
-    for (auto& observer : observers_)
-      observer.ReadingListWillUpdateReadEntry(
-          this, std::distance(read_->begin(), result));
-    result->SetDistilledState(state);
-    if (storage_layer_) {
-      storage_layer_->SaveEntry(*result, true);
-    }
-    for (auto& observer : observers_)
-      observer.ReadingListDidApplyChanges(this);
-    return;
+  for (ReadingListModelObserver& observer : observers_) {
+    observer.ReadingListWillUpdateEntry(this, url);
   }
-};
+  entry.SetDistilledState(state);
+  if (storage_layer_) {
+    storage_layer_->SaveEntry(GetEntryFromURL(url));
+  }
+  for (ReadingListModelObserver& observer : observers_) {
+    observer.ReadingListDidApplyChanges(this);
+  }
+}
 
 std::unique_ptr<ReadingListModel::ScopedReadingListBatchUpdate>
 ReadingListModelImpl::CreateBatchToken() {
   return base::MakeUnique<ReadingListModelImpl::ScopedReadingListBatchUpdate>(
       this);
 }
 
 ReadingListModelImpl::ScopedReadingListBatchUpdate::
     ScopedReadingListBatchUpdate(ReadingListModelImpl* model)
     : ReadingListModel::ScopedReadingListBatchUpdate::
           ScopedReadingListBatchUpdate(model) {
   if (model->StorageLayer()) {
     storage_token_ = model->StorageLayer()->EnsureBatchCreated();
   }
 }
 
 ReadingListModelImpl::ScopedReadingListBatchUpdate::
     ~ScopedReadingListBatchUpdate() {
   storage_token_.reset();
 }
 
 void ReadingListModelImpl::LeavingBatchUpdates() {
   DCHECK(CalledOnValidThread());
   if (storage_layer_) {
     SetPersistentHasUnseen(has_unseen_);
-    SortEntries();
   }
   ReadingListModel::LeavingBatchUpdates();
 }
 
 void ReadingListModelImpl::EnteringBatchUpdates() {
   DCHECK(CalledOnValidThread());
   ReadingListModel::EnteringBatchUpdates();
 }
 
 void ReadingListModelImpl::SetPersistentHasUnseen(bool has_unseen) {
@@ skipping 14 matching lines @@
       reading_list::prefs::kReadingListHasUnseenEntries);
 }
 
 syncer::ModelTypeSyncBridge* ReadingListModelImpl::GetModelTypeSyncBridge() {
   DCHECK(loaded());
   if (!storage_layer_)
     return nullptr;
   return storage_layer_->GetModelTypeSyncBridge();
 }
 
-void ReadingListModelImpl::SortEntries() {
-  DCHECK(CalledOnValidThread());
-  DCHECK(loaded());
-  std::sort(read_->begin(), read_->end(),
-            ReadingListEntry::CompareEntryUpdateTime);
-  std::sort(unread_->begin(), unread_->end(),
-            ReadingListEntry::CompareEntryUpdateTime);
-}
-
 ReadingListModelStorage* ReadingListModelImpl::StorageLayer() {
   return storage_layer_.get();
 }