[remote suggestions] Attach the fetch time to RemoteSnippets, ContentSnippets and SnippetArticle

components/ntp_snippets/remote/remote_suggestion.cc

 // Copyright 2015 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/ntp_snippets/remote/remote_suggestion.h"
 
 #include "base/feature_list.h"
 #include "base/memory/ptr_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
@@ skipping 78 matching lines @@
       score_(0),
       is_dismissed_(false),
       remote_category_id_(remote_category_id),
       should_notify_(false) {}
 
 RemoteSuggestion::~RemoteSuggestion() = default;
 
 // static
 std::unique_ptr<RemoteSuggestion>
 RemoteSuggestion::CreateFromChromeReaderDictionary(
-    const base::DictionaryValue& dict) {
+    const base::DictionaryValue& dict,
+    const base::Time& fetch_date) {
   const base::DictionaryValue* content = nullptr;
   if (!dict.GetDictionary("contentInfo", &content)) {
     return nullptr;
   }
 
   // Need at least a primary id.
   std::string primary_id;
   if (!content->GetString("url", &primary_id) || primary_id.empty()) {
     return nullptr;
   }
@@ skipping 50 matching lines @@
     // this for the primary ID).
     ids.push_back(corpus_id_str);
   }
   if (sources.empty()) {
     DLOG(WARNING) << "No sources found for article " << primary_id;
     return nullptr;
   }
 
   std::unique_ptr<RemoteSuggestion> snippet(
       new RemoteSuggestion(ids, kArticlesRemoteId));
+  snippet->fetch_date_ = fetch_date;
 
   std::string title;
   if (content->GetString("title", &title)) {
     snippet->title_ = title;
   }
   std::string salient_image_url;
   if (content->GetString("thumbnailUrl", &salient_image_url)) {
     snippet->salient_image_url_ = GURL(salient_image_url);
   }
   std::string snippet_str;
@@ skipping 30 matching lines @@
     snippet->score_ = score;
   }
 
   return snippet;
 }
 
 // static
 std::unique_ptr<RemoteSuggestion>
 RemoteSuggestion::CreateFromContentSuggestionsDictionary(
     const base::DictionaryValue& dict,
-    int remote_category_id) {
+    int remote_category_id,
+    const base::Time& fetch_date) {
   const base::ListValue* ids;
   if (!dict.GetList("ids", &ids)) {
     return nullptr;
   }
   std::vector<std::string> parsed_ids;
   for (const auto& value : *ids) {
     std::string id;
     if (!value->GetAsString(&id)) {
       return nullptr;
     }
     parsed_ids.push_back(id);
   }
 
   if (parsed_ids.empty()) {
     return nullptr;
   }
   auto snippet = MakeUnique(parsed_ids, remote_category_id);
+  snippet->fetch_date_ = fetch_date;
 
   if (!(dict.GetString("title", &snippet->title_) &&
         dict.GetString("snippet", &snippet->snippet_) &&
         GetTimeValue(dict, "creationTime", &snippet->publish_date_) &&
         GetTimeValue(dict, "expirationTime", &snippet->expiry_date_) &&
         GetURLValue(dict, "imageUrl", &snippet->salient_image_url_) &&
         dict.GetString("attribution", &snippet->publisher_name_) &&
         GetURLValue(dict, "fullPageUrl", &snippet->url_))) {
     return nullptr;
   }
@@ skipping 26 matching lines @@
   // Need at least the id.
   if (proto.ids_size() == 0 || proto.ids(0).empty()) {
     return nullptr;
   }
 
   int remote_category_id = proto.has_remote_category_id()
                                ? proto.remote_category_id()
                                : kArticlesRemoteId;
 
   std::vector<std::string> ids(proto.ids().begin(), proto.ids().end());
+
   auto snippet = MakeUnique(ids, remote_category_id);
 
   snippet->title_ = proto.title();
   snippet->snippet_ = proto.snippet();
   snippet->salient_image_url_ = GURL(proto.salient_image_url());
   snippet->publish_date_ = base::Time::FromInternalValue(proto.publish_date());
   snippet->expiry_date_ = base::Time::FromInternalValue(proto.expiry_date());
   snippet->score_ = proto.score();
   snippet->is_dismissed_ = proto.dismissed();
 
@@ skipping 18 matching lines @@
 
   if (sources.empty()) {
     DLOG(WARNING) << "No sources found for article " << snippet->id();
     return nullptr;
   }
   const SnippetSource& source = FindBestSource(sources);
   snippet->url_ = source.url;
   snippet->publisher_name_ = source.publisher_name;
   snippet->amp_url_ = source.amp_url;
 
+  if (proto.has_fetch_date()) {
+    snippet->fetch_date_ = base::Time::FromInternalValue(proto.fetch_date());
+  }
+
   return snippet;
 }
 
 // static
 std::unique_ptr<RemoteSuggestion> RemoteSuggestion::CreateForTesting(
     const std::string& id,
     int remote_category_id,
     const GURL& url,
     const std::string& publisher_name,
     const GURL& amp_url) {
@@ skipping 32 matching lines @@
 
   SnippetSourceProto* source_proto = result.add_sources();
   source_proto->set_url(url_.spec());
   if (!publisher_name_.empty()) {
     source_proto->set_publisher_name(publisher_name_);
   }
   if (amp_url_.is_valid()) {
     source_proto->set_amp_url(amp_url_.spec());
   }
 
+  if (!fetch_date_.is_null()) {
+    result.set_fetch_date(fetch_date_.ToInternalValue());
+  }
   return result;
 }
 
 ContentSuggestion RemoteSuggestion::ToContentSuggestion(
     Category category) const {
   GURL url = url_;
   if (base::FeatureList::IsEnabled(kPreferAmpUrlsFeature) &&
       !amp_url_.is_empty()) {
     url = amp_url_;
   }
   ContentSuggestion suggestion(category, id(), url);
   suggestion.set_title(base::UTF8ToUTF16(title_));
   suggestion.set_snippet_text(base::UTF8ToUTF16(snippet_));
   suggestion.set_publish_date(publish_date_);
   suggestion.set_publisher_name(base::UTF8ToUTF16(publisher_name_));
   suggestion.set_score(score_);
   if (should_notify_) {
     NotificationExtra extra;
     extra.deadline = notification_deadline_;
     suggestion.set_notification_extra(
         base::MakeUnique<NotificationExtra>(extra));
   }
+  suggestion.set_fetch_date(fetch_date_);
   return suggestion;
 }
 
 // static
 base::Time RemoteSuggestion::TimeFromJsonString(
     const std::string& timestamp_str) {
   int64_t timestamp;
   if (!base::StringToInt64(timestamp_str, &timestamp)) {
     // Even if there's an error in the conversion, some garbage data may still
     // be written to the output var, so reset it.
     DLOG(WARNING) << "Invalid json timestamp: " << timestamp_str;
     timestamp = 0;
   }
   return base::Time::UnixEpoch() + base::TimeDelta::FromSeconds(timestamp);
 }
 
 // static
 std::string RemoteSuggestion::TimeToJsonString(const base::Time& time) {
   return base::Int64ToString((time - base::Time::UnixEpoch()).InSeconds());
 }
 
 // static
 std::unique_ptr<RemoteSuggestion> RemoteSuggestion::MakeUnique(
     const std::vector<std::string>& ids,
     int remote_category_id) {
   return base::WrapUnique(new RemoteSuggestion(ids, remote_category_id));
 }
 
 }  // namespace ntp_snippets