[Reading List iOS] Store distillation date and size.

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"
@@ skipping 38 matching lines @@
                        title,
                        UNSEEN,
                        0,
                        0,
                        0,
                        0,
                        WAITING,
                        base::FilePath(),
                        GURL(),
                        0,
+                       0,
+                       0,
                        std::move(backoff)) {}
 
 ReadingListEntry::ReadingListEntry(
     const GURL& url,
     const std::string& title,
     State state,
     int64_t creation_time,
     int64_t first_read_time,
     int64_t update_time,
     int64_t update_title_time,
     ReadingListEntry::DistillationState distilled_state,
     const base::FilePath& distilled_path,
     const GURL& distilled_url,
+    int64_t distillation_time,
+    int64_t distillation_size,
     int failed_download_counter,
     std::unique_ptr<net::BackoffEntry> backoff)
     : url_(url),
       title_(title),
       state_(state),
       distilled_path_(distilled_path),
       distilled_url_(distilled_url),
       distilled_state_(distilled_state),
       failed_download_counter_(failed_download_counter),
       creation_time_us_(creation_time),
       first_read_time_us_(first_read_time),
       update_time_us_(update_time),
-      update_title_time_us_(update_title_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(!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_)),
       distilled_state_(std::move(entry.distilled_state_)),
       backoff_(std::move(entry.backoff_)),
       failed_download_counter_(std::move(entry.failed_download_counter_)),
       creation_time_us_(std::move(entry.creation_time_us_)),
       first_read_time_us_(std::move(entry.first_read_time_us_)),
       update_time_us_(std::move(entry.update_time_us_)),
-      update_title_time_us_(std::move(entry.update_title_time_us_)) {}
+      update_title_time_us_(std::move(entry.update_title_time_us_)),
+      distillation_time_us_(std::move(entry.distillation_time_us_)),
+      distillation_size_(std::move(entry.distillation_size_)) {}
 
 ReadingListEntry::~ReadingListEntry() {}
 
 const GURL& ReadingListEntry::URL() const {
   return url_;
 }
 
 const std::string& ReadingListEntry::Title() const {
   return title_;
 }
 
 ReadingListEntry::DistillationState ReadingListEntry::DistilledState() const {
   return distilled_state_;
 }
 
 const base::FilePath& ReadingListEntry::DistilledPath() const {
   return distilled_path_;
 }
 
 const GURL& ReadingListEntry::DistilledURL() const {
   return distilled_url_;
 }
 
+int64_t ReadingListEntry::DistillationTime() const {
+  return distillation_time_us_;
+}
+
+int64_t ReadingListEntry::DistillationSize() const {
+  return distillation_size_;
+}
+
 base::TimeDelta ReadingListEntry::TimeUntilNextTry() const {
   return backoff_->GetTimeUntilRelease();
 }
 
 int ReadingListEntry::FailedDownloadCounter() const {
   return failed_download_counter_;
 }
 
 ReadingListEntry& ReadingListEntry::operator=(ReadingListEntry&& other) {
   url_ = std::move(other.url_);
   title_ = std::move(other.title_);
   distilled_path_ = std::move(other.distilled_path_);
   distilled_url_ = std::move(other.distilled_url_);
   distilled_state_ = std::move(other.distilled_state_);
   backoff_ = std::move(other.backoff_);
   state_ = std::move(other.state_);
   failed_download_counter_ = std::move(other.failed_download_counter_);
   creation_time_us_ = std::move(other.creation_time_us_);
   first_read_time_us_ = std::move(other.first_read_time_us_);
   update_time_us_ = std::move(other.update_time_us_);
   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) {
   title_ = title;
   update_title_time_us_ =
@@ skipping 19 matching lines @@
 
 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) {
+                                        const GURL& distilled_url,
+                                        int64_t distilation_size,
+                                        int64_t 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_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.
   if ((distilled_state == WILL_RETRY || distilled_state == ERROR) &&
@@ skipping 103 matching lines @@
   base::FilePath distilled_path;
   if (pb_entry.has_distilled_path()) {
     distilled_path = base::FilePath(pb_entry.distilled_path());
   }
 
   GURL distilled_url;
   if (pb_entry.has_distilled_url()) {
     distilled_url = GURL(pb_entry.distilled_url());
   }
 
+  int64_t distillation_time_us = 0;
+  if (pb_entry.has_distillation_time_us()) {
+    distillation_time_us = pb_entry.distillation_time_us();
+  }
+
+  int64_t distillation_size = 0;
+  if (pb_entry.has_distillation_size()) {
+    distillation_size = pb_entry.distillation_size();
+  }
+
   int64_t failed_download_counter = 0;
   if (pb_entry.has_failed_download_counter()) {
     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());
     }
   }
 
   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,
-      failed_download_counter, std::move(backoff)));
+      distillation_time_us, distillation_size, failed_download_counter,
+      std::move(backoff)));
 }
 
 // static
 std::unique_ptr<ReadingListEntry> ReadingListEntry::FromReadingListSpecifics(
     const sync_pb::ReadingListSpecifics& pb_entry) {
   if (!pb_entry.has_url()) {
     return nullptr;
   }
   GURL url(pb_entry.url());
   if (url.is_empty() || !url.is_valid()) {
@@ skipping 34 matching lines @@
         state = UNREAD;
         break;
       case sync_pb::ReadingListSpecifics::UNSEEN:
         state = UNSEEN;
         break;
     }
   }
 
   return base::WrapUnique<ReadingListEntry>(new ReadingListEntry(
       url, title, state, creation_time_us, first_read_time_us, update_time_us,
-      update_title_time_us, WAITING, base::FilePath(), GURL(), 0, nullptr));
+      update_title_time_us, WAITING, base::FilePath(), GURL(), 0, 0, 0,
+      nullptr));
 }
 
 void ReadingListEntry::MergeWithEntry(const ReadingListEntry& other) {
 #if !defined(NDEBUG)
   // Checks that the result entry respects the sync order.
   std::unique_ptr<sync_pb::ReadingListSpecifics> old_this_pb(
       AsReadingListSpecifics());
   std::unique_ptr<sync_pb::ReadingListSpecifics> other_pb(
       other.AsReadingListSpecifics());
 #endif
@@ skipping 86 matching lines @@
       distilation_state = reading_list::ReadingListLocal::ERROR;
       break;
   }
   pb_entry->set_distillation_state(distilation_state);
   if (!DistilledPath().empty()) {
     pb_entry->set_distilled_path(DistilledPath().value());
   }
   if (DistilledURL().is_valid()) {
     pb_entry->set_distilled_url(DistilledURL().spec());
   }
+  if (DistillationTime()) {
+    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());
 
     std::string output;
     JSONStringValueSerializer serializer(&output);
     serializer.Serialize(*backoff);
@@ skipping 24 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;
 }