Expose notification info in ContentSuggestion

components/ntp_snippets/remote/ntp_snippet.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/ntp_snippet.h"
 
+#include "base/feature_list.h"
 #include "base/memory/ptr_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
+#include "base/strings/utf_string_conversions.h"
 #include "base/values.h"
 #include "components/ntp_snippets/category.h"
+#include "components/ntp_snippets/features.h"
 #include "components/ntp_snippets/remote/proto/ntp_snippets.pb.h"
 
 namespace {
 
 struct SnippetSource {
   SnippetSource(const GURL& url,
                 const std::string& publisher_name,
                 const GURL& amp_url)
       : url(url), publisher_name(publisher_name), amp_url(amp_url) {}
   GURL url;
@@ skipping 56 matching lines @@
         kArticlesRemoteId,
     "kArticlesRemoteId has a wrong value?!");
 
 const int kChromeReaderDefaultExpiryTimeMins = 3 * 24 * 60;
 
 NTPSnippet::NTPSnippet(const std::vector<std::string>& ids,
                        int remote_category_id)
     : ids_(ids),
       score_(0),
       is_dismissed_(false),
-      remote_category_id_(remote_category_id) {}
+      remote_category_id_(remote_category_id),
+      should_notify_(false) {}
 
 NTPSnippet::~NTPSnippet() = default;
 
 // static
 std::unique_ptr<NTPSnippet> NTPSnippet::CreateFromChromeReaderDictionary(
     const base::DictionaryValue& dict) {
   const base::DictionaryValue* content = nullptr;
   if (!dict.GetDictionary("contentInfo", &content)) {
     return nullptr;
   }
@@ skipping 140 matching lines @@
     return nullptr;
   }
   GetURLValue(dict, "ampUrl", &snippet->amp_url_);  // May fail; OK.
   // TODO(sfiera): also favicon URL.
 
   double score;
   if (dict.GetDouble("score", &score)) {
     snippet->score_ = score;
   }
 
+  const base::DictionaryValue* notification_info = nullptr;
+  if (dict.GetDictionary("notificationInfo", &notification_info)) {
+    if (notification_info->GetBoolean("shouldNotify",
+                                      &snippet->should_notify_) &&
+        snippet->should_notify_) {
+      if (!GetTimeValue(*notification_info, "deadline",
+                        &snippet->notification_deadline_)) {
+        snippet->notification_deadline_ = base::Time::Max();
+      }
+    }
+  }
+
   return snippet;
 }
 
 // static
 std::unique_ptr<NTPSnippet> NTPSnippet::CreateFromProto(
     const SnippetProto& proto) {
   // Need at least the id.
   if (proto.ids_size() == 0 || proto.ids(0).empty()) {
     return nullptr;
   }
@@ skipping 89 matching lines @@
   if (!publisher_name_.empty()) {
     source_proto->set_publisher_name(publisher_name_);
   }
   if (amp_url_.is_valid()) {
     source_proto->set_amp_url(amp_url_.spec());
   }
 
   return result;
 }
 
+ContentSuggestion NTPSnippet::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));
+  }
+  return suggestion;
+}
+
 // static
 base::Time NTPSnippet::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 NTPSnippet::TimeToJsonString(const base::Time& time) {
   return base::Int64ToString((time - base::Time::UnixEpoch()).InSeconds());
 }
 
 // static
 std::unique_ptr<NTPSnippet> NTPSnippet::MakeUnique(
     const std::vector<std::string>& ids, int remote_category_id) {
   return base::WrapUnique(new NTPSnippet(ids, remote_category_id));
 }
 
 }  // namespace ntp_snippets