Reading List iOS: Use external clock in ReadingListEntry.

components/reading_list/ios/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 "components/reading_list/ios/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 "base/time/clock.h"
 #include "components/prefs/pref_service.h"
 #include "components/reading_list/ios/reading_list_model_storage.h"
 #include "components/reading_list/ios/reading_list_pref_names.h"
 #include "url/gurl.h"
 
-ReadingListModelImpl::ReadingListModelImpl()
-    : ReadingListModelImpl(nullptr, nullptr) {}
-
 ReadingListModelImpl::ReadingListModelImpl(
     std::unique_ptr<ReadingListModelStorage> storage,
-    PrefService* pref_service)
+    PrefService* pref_service,
+    std::unique_ptr<base::Clock> clock)
     : entries_(base::MakeUnique<ReadingListEntries>()),
       unread_entry_count_(0),
       read_entry_count_(0),
       unseen_entry_count_(0),
+      clock_(std::move(clock)),
       pref_service_(pref_service),
       has_unseen_(false),
       loaded_(false),
       weak_ptr_factory_(this) {
   DCHECK(CalledOnValidThread());
+  DCHECK(clock_);
   if (storage) {
     storage_layer_ = std::move(storage);
-    storage_layer_->SetReadingListModel(this, this);
+    storage_layer_->SetReadingListModel(this, this, clock_.get());
   } else {
     loaded_ = true;
   }
   has_unseen_ = GetPersistentHasUnseen();
 }
 
 ReadingListModelImpl::~ReadingListModelImpl() {}
 
 void ReadingListModelImpl::StoreLoaded(
     std::unique_ptr<ReadingListEntries> entries) {
@@ skipping 83 matching lines @@
       model_batch_updates = BeginBatchUpdates();
   for (auto& iterator : *entries_) {
     ReadingListEntry& entry = iterator.second;
     if (entry.HasBeenSeen()) {
       continue;
     }
     for (auto& observer : observers_) {
       observer.ReadingListWillUpdateEntry(this, iterator.first);
     }
     UpdateEntryStateCountersOnEntryRemoval(entry);
-    entry.SetRead(false);
+    entry.SetRead(false, clock_->Now());
     UpdateEntryStateCountersOnEntryInsertion(entry);
     if (storage_layer_) {
       storage_layer_->SaveEntry(entry);
     }
     for (auto& observer : observers_) {
       observer.ReadingListDidApplyChanges(this);
     }
   }
   DCHECK(unseen_entry_count_ == 0);
 }
@@ skipping 163 matching lines @@
     const GURL& url,
     const std::string& title,
     reading_list::EntrySource source) {
   DCHECK(CalledOnValidThread());
   DCHECK(loaded());
   DCHECK(url.SchemeIsHTTPOrHTTPS());
   RemoveEntryByURL(url);
 
   std::string trimmed_title = base::CollapseWhitespaceASCII(title, false);
 
-  ReadingListEntry entry(url, trimmed_title);
+  ReadingListEntry entry(url, trimmed_title, clock_->Now());
   for (auto& observer : observers_)
     observer.ReadingListWillAddEntry(this, entry);
   UpdateEntryStateCountersOnEntryInsertion(entry);
   SetUnseenFlag();
   entries_->insert(std::make_pair(url, std::move(entry)));
 
   if (storage_layer_) {
     storage_layer_->SaveEntry(*GetEntryByURL(url));
   }
 
@@ skipping 13 matching lines @@
     return;
   }
   ReadingListEntry& entry = iterator->second;
   if (entry.IsRead() == read) {
     return;
   }
   for (ReadingListModelObserver& observer : observers_) {
     observer.ReadingListWillMoveEntry(this, url);
   }
   UpdateEntryStateCountersOnEntryRemoval(entry);
-  entry.SetRead(read);
-  entry.MarkEntryUpdated();
+  entry.SetRead(read, clock_->Now());
+  entry.MarkEntryUpdated(clock_->Now());
   UpdateEntryStateCountersOnEntryInsertion(entry);
 
   if (storage_layer_) {
     storage_layer_->SaveEntry(entry);
   }
   for (ReadingListModelObserver& observer : observers_) {
     observer.ReadingListDidMoveEntry(this, url);
     observer.ReadingListDidApplyChanges(this);
   }
 }
 
 void ReadingListModelImpl::SetEntryTitle(const GURL& url,
                                          const std::string& title) {
   DCHECK(CalledOnValidThread());
   DCHECK(loaded());
   auto iterator = entries_->find(url);
   if (iterator == entries_->end()) {
     return;
   }
   ReadingListEntry& entry = iterator->second;
   std::string trimmed_title = base::CollapseWhitespaceASCII(title, false);
   if (entry.Title() == trimmed_title) {
     return;
   }
 
   for (ReadingListModelObserver& observer : observers_) {
     observer.ReadingListWillUpdateEntry(this, url);
   }
-  entry.SetTitle(trimmed_title);
+  entry.SetTitle(trimmed_title, clock_->Now());
   if (storage_layer_) {
     storage_layer_->SaveEntry(entry);
   }
   for (ReadingListModelObserver& observer : observers_) {
     observer.ReadingListDidApplyChanges(this);
   }
 }
 
 void ReadingListModelImpl::SetEntryDistilledInfo(
     const GURL& url,
     const base::FilePath& distilled_path,
     const GURL& distilled_url,
     int64_t distillation_size,
-    int64_t distillation_date) {
+    const base::Time& distillation_date) {
   DCHECK(CalledOnValidThread());
   DCHECK(loaded());
   auto iterator = entries_->find(url);
   if (iterator == entries_->end()) {
     return;
   }
   ReadingListEntry& entry = iterator->second;
   if (entry.DistilledState() == ReadingListEntry::PROCESSED &&
       entry.DistilledPath() == distilled_path) {
     return;
@@ skipping 91 matching lines @@
 
 syncer::ModelTypeSyncBridge* ReadingListModelImpl::GetModelTypeSyncBridge() {
   if (!storage_layer_)
     return nullptr;
   return storage_layer_.get();
 }
 
 ReadingListModelStorage* ReadingListModelImpl::StorageLayer() {
   return storage_layer_.get();
 }