Reading List iOS: Use external clock in ReadingListEntry.

components/reading_list/ios/reading_list_model_impl.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_MODEL_IMPL_H_
 #define COMPONENTS_READING_LIST_IOS_READING_LIST_MODEL_IMPL_H_
 
 #include <map>
 #include <memory>
 
 #include "components/keyed_service/core/keyed_service.h"
 #include "components/reading_list/ios/reading_list_entry.h"
 #include "components/reading_list/ios/reading_list_model.h"
 #include "components/reading_list/ios/reading_list_model_storage.h"
 #include "components/reading_list/ios/reading_list_store_delegate.h"
 
+namespace base {
+class Clock;
+}
+
 class PrefService;
 
 // Concrete implementation of a reading list model using in memory lists.
 class ReadingListModelImpl : public ReadingListModel,
                              public ReadingListStoreDelegate,
                              public KeyedService {
  public:
   using ReadingListEntries = std::map<GURL, ReadingListEntry>;
 
   // Initialize a ReadingListModelImpl to load and save data in
-  // |persistence_layer|.
+  // |storage_layer|. Passing null to |storage_layer| will create a
+  // ReadingListModelImpl without persistence. Data will not be persistent
+  // across sessions.
+  // |clock| will be used to timestamp all the operations.
   ReadingListModelImpl(std::unique_ptr<ReadingListModelStorage> storage_layer,
-                       PrefService* pref_service);
+                       PrefService* pref_service,
+                       std::unique_ptr<base::Clock> clock_);
 
-  // Initialize a ReadingListModelImpl without persistence. Data will not be
-  // persistent across sessions.
   ReadingListModelImpl();
 
   syncer::ModelTypeSyncBridge* GetModelTypeSyncBridge() override;
 
   ~ReadingListModelImpl() override;
 
   void StoreLoaded(std::unique_ptr<ReadingListEntries> entries) override;
 
   // KeyedService implementation.
   void Shutdown() override;
@@ skipping 23 matching lines @@
   void SetReadStatus(const GURL& url, bool read) override;
 
   void SetEntryTitle(const GURL& url, const std::string& title) override;
   void SetEntryDistilledState(
       const GURL& url,
       ReadingListEntry::DistillationState state) override;
   void SetEntryDistilledInfo(const GURL& url,
                              const base::FilePath& distilled_path,
                              const GURL& distilled_url,
                              int64_t distillation_size,
-                             int64_t distillation_date) override;
+                             const base::Time& distillation_date) override;
 
   void SyncAddEntry(std::unique_ptr<ReadingListEntry> entry) override;
   ReadingListEntry* SyncMergeEntry(
       std::unique_ptr<ReadingListEntry> entry) override;
   void SyncRemoveEntry(const GURL& url) override;
 
   std::unique_ptr<ReadingListModel::ScopedReadingListBatchUpdate>
   CreateBatchToken() override;
 
   // Helper class that is used to scope batch updates.
@@ skipping 37 matching lines @@
   size_t read_entry_count_;
   size_t unseen_entry_count_;
 
   // Update the 3 counts above considering addition/removal of |entry|.
   void UpdateEntryStateCountersOnEntryRemoval(const ReadingListEntry& entry);
   void UpdateEntryStateCountersOnEntryInsertion(const ReadingListEntry& entry);
 
   // Set the unseen flag to true.
   void SetUnseenFlag();
 
+  // |storage_layer_| depends on |clock_| so keep the order.
+  std::unique_ptr<base::Clock> clock_;
   std::unique_ptr<ReadingListModelStorage> storage_layer_;
   PrefService* pref_service_;
   bool has_unseen_;
   bool loaded_;
+
   base::WeakPtrFactory<ReadingListModelImpl> weak_ptr_factory_;
+
   DISALLOW_COPY_AND_ASSIGN(ReadingListModelImpl);
 };
 
 #endif  // COMPONENTS_READING_LIST_IOS_READING_LIST_MODEL_IMPL_H_