Reading List iOS: Use external clock in ReadingListEntry.

components/reading_list/ios/reading_list_store.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_store.h"
 
 #include <set>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
+#include "base/time/clock.h"
 #include "components/reading_list/ios/proto/reading_list.pb.h"
 #include "components/reading_list/ios/reading_list_model_impl.h"
 #include "components/sync/model/entity_change.h"
 #include "components/sync/model/metadata_batch.h"
 #include "components/sync/model/metadata_change_list.h"
 #include "components/sync/model/model_type_change_processor.h"
 #include "components/sync/model/mutable_data_batch.h"
 #include "components/sync/model_impl/accumulating_metadata_change_list.h"
 #include "components/sync/protocol/model_type_state.pb.h"
 
 ReadingListStore::ReadingListStore(
     StoreFactoryFunction create_store_callback,
     const ChangeProcessorFactory& change_processor_factory)
     : ReadingListModelStorage(change_processor_factory, syncer::READING_LIST),
       create_store_callback_(create_store_callback),
       pending_transaction_count_(0) {}
 
 ReadingListStore::~ReadingListStore() {
   DCHECK_EQ(0, pending_transaction_count_);
 }
 
 void ReadingListStore::SetReadingListModel(ReadingListModel* model,
-                                           ReadingListStoreDelegate* delegate) {
+                                           ReadingListStoreDelegate* delegate,
+                                           base::Clock* clock) {
   DCHECK(CalledOnValidThread());
   model_ = model;
   delegate_ = delegate;
+  clock_ = clock;
   create_store_callback_.Run(
       base::Bind(&ReadingListStore::OnStoreCreated, base::AsWeakPtr(this)));
 }
 
 std::unique_ptr<ReadingListModelStorage::ScopedBatchUpdate>
 ReadingListStore::EnsureBatchCreated() {
   return base::WrapUnique<ReadingListModelStorage::ScopedBatchUpdate>(
       new ScopedBatchUpdate(this));
 }
 
@@ skipping 23 matching lines @@
         base::Bind(&ReadingListStore::OnDatabaseSave, base::AsWeakPtr(this)));
     batch_.reset();
   }
 }
 
 void ReadingListStore::SaveEntry(const ReadingListEntry& entry) {
   DCHECK(CalledOnValidThread());
   auto token = EnsureBatchCreated();
 
   std::unique_ptr<reading_list::ReadingListLocal> pb_entry =
-      entry.AsReadingListLocal();
+      entry.AsReadingListLocal(clock_->Now());
 
   batch_->WriteData(entry.URL().spec(), pb_entry->SerializeAsString());
 
   if (!change_processor()->IsTrackingMetadata()) {
     return;
   }
   std::unique_ptr<sync_pb::ReadingListSpecifics> pb_entry_sync =
       entry.AsReadingListSpecifics();
 
   std::unique_ptr<syncer::MetadataChangeList> metadata_change_list =
@@ skipping 37 matching lines @@
 
   for (const syncer::ModelTypeStore::Record& r : *entries.get()) {
     reading_list::ReadingListLocal proto;
     if (!proto.ParseFromString(r.value)) {
       continue;
       // TODO(skym, crbug.com/582460): Handle unrecoverable initialization
       // failure.
     }
 
     std::unique_ptr<ReadingListEntry> entry(
-        ReadingListEntry::FromReadingListLocal(proto));
+        ReadingListEntry::FromReadingListLocal(proto, clock_->Now()));
     if (!entry) {
       continue;
     }
     GURL url = entry->URL();
     DCHECK(!loaded_entries->count(url));
     loaded_entries->insert(std::make_pair(url, std::move(*entry)));
   }
 
   delegate_->StoreLoaded(std::move(loaded_entries));
 
@@ skipping 60 matching lines @@
   std::unique_ptr<ReadingListModel::ScopedReadingListBatchUpdate>
       model_batch_updates = model_->BeginBatchUpdates();
 
   // Merge sync to local data.
   for (const auto& kv : entity_data_map) {
     synced_entries.insert(kv.first);
     const sync_pb::ReadingListSpecifics& specifics =
         kv.second.value().specifics.reading_list();
     // Deserialize entry.
     std::unique_ptr<ReadingListEntry> entry(
-        ReadingListEntry::FromReadingListSpecifics(specifics));
+        ReadingListEntry::FromReadingListSpecifics(specifics, clock_->Now()));
 
     const ReadingListEntry* existing_entry =
         model_->GetEntryByURL(entry->URL());
 
     if (!existing_entry) {
       // This entry is new. Add it to the store and model.
       // Convert to local store format and write to store.
       std::unique_ptr<reading_list::ReadingListLocal> entry_pb =
-          entry->AsReadingListLocal();
+          entry->AsReadingListLocal(clock_->Now());
       batch_->WriteData(entry->URL().spec(), entry_pb->SerializeAsString());
 
       // Notify model about updated entry.
       delegate_->SyncAddEntry(std::move(entry));
     } else {
       // Merge the local data and the sync data and store the result.
       ReadingListEntry* merged_entry =
           delegate_->SyncMergeEntry(std::move(entry));
 
       // Write to the store.
       std::unique_ptr<reading_list::ReadingListLocal> entry_local_pb =
-          merged_entry->AsReadingListLocal();
+          merged_entry->AsReadingListLocal(clock_->Now());
       batch_->WriteData(merged_entry->URL().spec(),
                         entry_local_pb->SerializeAsString());
 
       // Send to sync
       std::unique_ptr<sync_pb::ReadingListSpecifics> entry_sync_pb =
           merged_entry->AsReadingListSpecifics();
       DCHECK(CompareEntriesForSync(specifics, *entry_sync_pb));
       auto entity_data = base::MakeUnique<syncer::EntityData>();
       *(entity_data->specifics.mutable_reading_list()) = *entry_sync_pb;
       entity_data->non_unique_name = entry_sync_pb->entry_id();
@@ skipping 45 matching lines @@
   for (syncer::EntityChange& change : entity_changes) {
     if (change.type() == syncer::EntityChange::ACTION_DELETE) {
       batch_->DeleteData(change.storage_key());
       // Need to notify model that entry is deleted.
       delegate_->SyncRemoveEntry(GURL(change.storage_key()));
     } else {
       // Deserialize entry.
       const sync_pb::ReadingListSpecifics& specifics =
           change.data().specifics.reading_list();
       std::unique_ptr<ReadingListEntry> entry(
-          ReadingListEntry::FromReadingListSpecifics(specifics));
+          ReadingListEntry::FromReadingListSpecifics(specifics, clock_->Now()));
 
       const ReadingListEntry* existing_entry =
           model_->GetEntryByURL(entry->URL());
 
       if (!existing_entry) {
         // This entry is new. Add it to the store and model.
         // Convert to local store format and write to store.
         std::unique_ptr<reading_list::ReadingListLocal> entry_pb =
-            entry->AsReadingListLocal();
+            entry->AsReadingListLocal(clock_->Now());
         batch_->WriteData(entry->URL().spec(), entry_pb->SerializeAsString());
 
         // Notify model about updated entry.
         delegate_->SyncAddEntry(std::move(entry));
       } else {
         // Merge the local data and the sync data and store the result.
         ReadingListEntry* merged_entry =
             delegate_->SyncMergeEntry(std::move(entry));
 
         // Write to the store.
         std::unique_ptr<reading_list::ReadingListLocal> entry_local_pb =
-            merged_entry->AsReadingListLocal();
+            merged_entry->AsReadingListLocal(clock_->Now());
         batch_->WriteData(merged_entry->URL().spec(),
                           entry_local_pb->SerializeAsString());
 
         // Send to sync
         std::unique_ptr<sync_pb::ReadingListSpecifics> entry_sync_pb =
             merged_entry->AsReadingListSpecifics();
         DCHECK(CompareEntriesForSync(specifics, *entry_sync_pb));
         auto entity_data = base::MakeUnique<syncer::EntityData>();
         *(entity_data->specifics.mutable_reading_list()) = *entry_sync_pb;
         entity_data->non_unique_name = entry_sync_pb->entry_id();
@@ skipping 112 matching lines @@
     if (rhs.first_read_time_us() == 0 && lhs.first_read_time_us() != 0) {
       return false;
     }
     if (rhs.first_read_time_us() > lhs.first_read_time_us() &&
         lhs.first_read_time_us() != 0) {
       return false;
     }
   }
   return true;
 }