Reading List iOS: Use external clock in ReadingListEntry.

components/reading_list/ios/reading_list_entry.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_entry.h"
 
 #include "base/json/json_string_value_serializer.h"
 #include "base/memory/ptr_util.h"
 #include "components/reading_list/ios/offline_url_utils.h"
 #include "components/reading_list/ios/proto/reading_list.pb.h"
 #include "components/reading_list/ios/reading_list_store.h"
 #include "components/sync/protocol/reading_list_specifics.pb.h"
 #include "net/base/backoff_entry_serializer.h"
 
+namespace {
+// Converts |time| to the number of microseconds since Jan 1st 1970.
+int64_t TimeToUS(const base::Time& time) {
+  return (time - base::Time::UnixEpoch()).InMicroseconds();
+}
+}
+
 // The backoff time is the following: 10min, 10min, 1h, 2h, 2h..., starting
 // after the first failure.
 const net::BackoffEntry::Policy ReadingListEntry::kBackoffPolicy = {
     // Number of initial errors (in sequence) to ignore before applying
     // exponential back-off rules.
     2,
 
     // Initial delay for exponential back-off in ms.
     10 * 60 * 1000,  // 10 minutes.
 
     // Factor by which the waiting time will be multiplied.
     6,
 
     // Fuzzing percentage. ex: 10% will spread requests randomly
     // between 90%-100% of the calculated time.
     0.1,  // 10%.
 
     // Maximum amount of time we are willing to delay our request in ms.
     2 * 3600 * 1000,  // 2 hours.
 
     // Time to keep an entry from being discarded even when it
     // has no significant state, -1 to never discard.
     -1,
 
     true,  // Don't use initial delay unless the last request was an error.
 };
 
-ReadingListEntry::ReadingListEntry(const GURL& url, const std::string& title)
-    : ReadingListEntry(url, title, nullptr){};
+ReadingListEntry::ReadingListEntry(const GURL& url,
+                                   const std::string& title,
+                                   const base::Time& now)
+    : ReadingListEntry(url, title, now, nullptr){};
 
 ReadingListEntry::ReadingListEntry(const GURL& url,
                                    const std::string& title,
+                                   const base::Time& now,
                                    std::unique_ptr<net::BackoffEntry> backoff)
     : ReadingListEntry(url,
                        title,
                        UNSEEN,
+                       TimeToUS(now),
                        0,
-                       0,
-                       0,
-                       0,
+                       TimeToUS(now),
+                       TimeToUS(now),
                        WAITING,
                        base::FilePath(),
                        GURL(),
                        0,
                        0,
                        0,
                        std::move(backoff)) {}
 
 ReadingListEntry::ReadingListEntry(
     const GURL& url,
@@ skipping 21 matching lines @@
       first_read_time_us_(first_read_time),
       update_time_us_(update_time),
       update_title_time_us_(update_title_time),
       distillation_time_us_(distillation_time),
       distillation_size_(distillation_size) {
   if (backoff) {
     backoff_ = std::move(backoff);
   } else {
     backoff_ = base::MakeUnique<net::BackoffEntry>(&kBackoffPolicy);
   }
-  if (creation_time_us_ == 0) {
-    DCHECK(update_time_us_ == 0);
-    DCHECK(update_title_time_us_ == 0);
-    creation_time_us_ =
-        (base::Time::Now() - base::Time::UnixEpoch()).InMicroseconds();
-    update_time_us_ = creation_time_us_;
-    update_title_time_us_ = creation_time_us_;
-  }
+  DCHECK(creation_time_us_);
+  DCHECK(update_time_us_);
+  DCHECK(update_title_time_us_);
   DCHECK(!url.is_empty());
   DCHECK(url.is_valid());
 }
 
 ReadingListEntry::ReadingListEntry(ReadingListEntry&& entry)
     : url_(std::move(entry.url_)),
       title_(std::move(entry.title_)),
       state_(std::move(entry.state_)),
       distilled_path_(std::move(entry.distilled_path_)),
       distilled_url_(std::move(entry.distilled_url_)),
@@ skipping 60 matching lines @@
   update_title_time_us_ = std::move(other.update_title_time_us_);
   distillation_time_us_ = std::move(other.distillation_time_us_);
   distillation_size_ = std::move(other.distillation_size_);
   return *this;
 }
 
 bool ReadingListEntry::operator==(const ReadingListEntry& other) const {
   return url_ == other.url_;
 }
 
-void ReadingListEntry::SetTitle(const std::string& title) {
+void ReadingListEntry::SetTitle(const std::string& title,
+                                const base::Time& now) {
   title_ = title;
-  update_title_time_us_ =
-      (base::Time::Now() - base::Time::UnixEpoch()).InMicroseconds();
+  update_title_time_us_ = TimeToUS(now);
 }
 
-void ReadingListEntry::SetRead(bool read) {
+void ReadingListEntry::SetRead(bool read, const base::Time& now) {
   State previous_state = state_;
   state_ = read ? READ : UNREAD;
   if (state_ == previous_state) {
     return;
   }
   if (FirstReadTime() == 0 && read) {
-    first_read_time_us_ =
-        (base::Time::Now() - base::Time::UnixEpoch()).InMicroseconds();
+    first_read_time_us_ = TimeToUS(now);
   }
   if (!(previous_state == UNSEEN && state_ == UNREAD)) {
     // If changing UNSEEN -> UNREAD, entry is not marked updated to preserve
     // order in Reading List View.
-    MarkEntryUpdated();
+    MarkEntryUpdated(now);
   }
 }
 
 bool ReadingListEntry::IsRead() const {
   return state_ == READ;
 }
 
 bool ReadingListEntry::HasBeenSeen() const {
   return state_ != UNSEEN;
 }
 
 void ReadingListEntry::SetDistilledInfo(const base::FilePath& path,
                                         const GURL& distilled_url,
                                         int64_t distilation_size,
-                                        int64_t distilation_time) {
+                                        const base::Time& distilation_time) {
   DCHECK(!path.empty());
   DCHECK(distilled_url.is_valid());
   distilled_path_ = path;
   distilled_state_ = PROCESSED;
   distilled_url_ = distilled_url;
-  distillation_time_us_ = distilation_time;
-  ;
+  distillation_time_us_ = TimeToUS(distilation_time);
   distillation_size_ = distilation_size;
   backoff_->Reset();
   failed_download_counter_ = 0;
 }
 
 void ReadingListEntry::SetDistilledState(DistillationState distilled_state) {
   DCHECK(distilled_state != PROCESSED);  // use SetDistilledPath instead.
   DCHECK(distilled_state != WAITING);
   // Increase time until next retry exponentially if the state change from a
   // non-error state to an error state.
@@ skipping 17 matching lines @@
 }
 
 int64_t ReadingListEntry::CreationTime() const {
   return creation_time_us_;
 }
 
 int64_t ReadingListEntry::FirstReadTime() const {
   return first_read_time_us_;
 }
 
-void ReadingListEntry::MarkEntryUpdated() {
-  update_time_us_ =
-      (base::Time::Now() - base::Time::UnixEpoch()).InMicroseconds();
+void ReadingListEntry::MarkEntryUpdated(const base::Time& now) {
+  update_time_us_ = TimeToUS(now);
 }
 
 // static
 std::unique_ptr<ReadingListEntry> ReadingListEntry::FromReadingListLocal(
-    const reading_list::ReadingListLocal& pb_entry) {
+    const reading_list::ReadingListLocal& pb_entry,
+    const base::Time& now) {
   if (!pb_entry.has_url()) {
     return nullptr;
   }
   GURL url(pb_entry.url());
   if (url.is_empty() || !url.is_valid()) {
     return nullptr;
   }
   std::string title;
   if (pb_entry.has_title()) {
     title = pb_entry.title();
   }
 
   int64_t creation_time_us = 0;
   if (pb_entry.has_creation_time_us()) {
     creation_time_us = pb_entry.creation_time_us();
+  } else {
+    creation_time_us = (now - base::Time::UnixEpoch()).InMicroseconds();

[gambard, 2017/03/21 13:08:06]

I am not sure I understand this. What is the use?

[Olivier, 2017/03/21 14:01:09]

We have to be conservative when deserializing data. So if there is no creation
date, just add one.

[gambard, 2017/03/21 15:36:53]

Acknowledged.

   }
 
   int64_t first_read_time_us = 0;
   if (pb_entry.has_first_read_time_us()) {
     first_read_time_us = pb_entry.first_read_time_us();
   }
 
-  int64_t update_time_us = 0;
+  int64_t update_time_us = creation_time_us;
   if (pb_entry.has_update_time_us()) {
     update_time_us = pb_entry.update_time_us();
   }
 
-  int64_t update_title_time_us = 0;
+  int64_t update_title_time_us = creation_time_us;
   if (pb_entry.has_update_title_time_us()) {
     update_title_time_us = pb_entry.update_title_time_us();
   }
 
   State state = UNSEEN;
   if (pb_entry.has_status()) {
     switch (pb_entry.status()) {
       case reading_list::ReadingListLocal::READ:
         state = READ;
         break;
@@ skipping 53 matching lines @@
     failed_download_counter = pb_entry.failed_download_counter();
   }
 
   std::unique_ptr<net::BackoffEntry> backoff;
   if (pb_entry.has_backoff()) {
     JSONStringValueDeserializer deserializer(pb_entry.backoff());
     std::unique_ptr<base::Value> value(
         deserializer.Deserialize(nullptr, nullptr));
     if (value) {
       backoff = net::BackoffEntrySerializer::DeserializeFromValue(
-          *value, &kBackoffPolicy, nullptr, base::Time::Now());
+          *value, &kBackoffPolicy, nullptr, now);
     }
   }
 
   return base::WrapUnique<ReadingListEntry>(new ReadingListEntry(
       url, title, state, creation_time_us, first_read_time_us, update_time_us,
       update_title_time_us, distillation_state, distilled_path, distilled_url,
       distillation_time_us, distillation_size, failed_download_counter,
       std::move(backoff)));
 }
 
 // static
 std::unique_ptr<ReadingListEntry> ReadingListEntry::FromReadingListSpecifics(
-    const sync_pb::ReadingListSpecifics& pb_entry) {
+    const sync_pb::ReadingListSpecifics& pb_entry,
+    const base::Time& now) {
   if (!pb_entry.has_url()) {
     return nullptr;
   }
   GURL url(pb_entry.url());
   if (url.is_empty() || !url.is_valid()) {
     return nullptr;
   }
   std::string title;
   if (pb_entry.has_title()) {
     title = pb_entry.title();
   }
 
-  int64_t creation_time_us = 0;
+  int64_t creation_time_us = TimeToUS(now);
   if (pb_entry.has_creation_time_us()) {
     creation_time_us = pb_entry.creation_time_us();
   }
 
   int64_t first_read_time_us = 0;
   if (pb_entry.has_first_read_time_us()) {
     first_read_time_us = pb_entry.first_read_time_us();
   }
 
-  int64_t update_time_us = 0;
+  int64_t update_time_us = creation_time_us;
   if (pb_entry.has_update_time_us()) {
     update_time_us = pb_entry.update_time_us();
   }
 
-  int64_t update_title_time_us = 0;
+  int64_t update_title_time_us = creation_time_us;
   if (pb_entry.has_update_title_time_us()) {
     update_title_time_us = pb_entry.update_title_time_us();
   }
 
   State state = UNSEEN;
   if (pb_entry.has_status()) {
     switch (pb_entry.status()) {
       case sync_pb::ReadingListSpecifics::READ:
         state = READ;
         break;
@@ skipping 58 matching lines @@
   }
 #if !defined(NDEBUG)
   std::unique_ptr<sync_pb::ReadingListSpecifics> new_this_pb(
       AsReadingListSpecifics());
   DCHECK(ReadingListStore::CompareEntriesForSync(*old_this_pb, *new_this_pb));
   DCHECK(ReadingListStore::CompareEntriesForSync(*other_pb, *new_this_pb));
 #endif
 }
 
 std::unique_ptr<reading_list::ReadingListLocal>
-ReadingListEntry::AsReadingListLocal() const {
+ReadingListEntry::AsReadingListLocal(const base::Time& now) const {
   std::unique_ptr<reading_list::ReadingListLocal> pb_entry =
       base::MakeUnique<reading_list::ReadingListLocal>();
 
   // URL is used as the key for the database and sync as there is only one entry
   // per URL.
   pb_entry->set_entry_id(URL().spec());
   pb_entry->set_title(Title());
   pb_entry->set_url(URL().spec());
   pb_entry->set_creation_time_us(CreationTime());
   pb_entry->set_first_read_time_us(FirstReadTime());
@@ skipping 41 matching lines @@
     pb_entry->set_distillation_time_us(DistillationTime());
   }
   if (DistillationSize()) {
     pb_entry->set_distillation_size(DistillationSize());
   }
 
   pb_entry->set_failed_download_counter(failed_download_counter_);
 
   if (backoff_) {
     std::unique_ptr<base::Value> backoff =
-        net::BackoffEntrySerializer::SerializeToValue(*backoff_,
-                                                      base::Time::Now());
+        net::BackoffEntrySerializer::SerializeToValue(*backoff_, now);
 
     std::string output;
     JSONStringValueSerializer serializer(&output);
     serializer.Serialize(*backoff);
     pb_entry->set_backoff(output);
   }
   return pb_entry;
 }
 
 std::unique_ptr<sync_pb::ReadingListSpecifics>
@@ skipping 18 matching lines @@
     case UNREAD:
       pb_entry->set_status(sync_pb::ReadingListSpecifics::UNREAD);
       break;
     case UNSEEN:
       pb_entry->set_status(sync_pb::ReadingListSpecifics::UNSEEN);
       break;
   }
 
   return pb_entry;
 }