[NTP Snippets] Persist non-article remote suggestions in the DB

components/ntp_snippets/remote/ntp_snippets_fetcher.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/ntp_snippets/remote/ntp_snippets_fetcher.h"
 
 #include <cstdlib>
 
 #include "base/command_line.h"
 #include "base/files/file_path.h"
@@ skipping 134 matching lines @@
       endpoint != GURL(kContentSuggestionsDevServer) &&
       endpoint != GURL(kContentSuggestionsAlphaServer)) {
     LOG(WARNING) << "Unknown value for " << kContentSuggestionsBackend << ": "
                  << "assuming chromecontentsuggestions-style API";
   }
   return true;
 }
 
 // Creates snippets from dictionary values in |list| and adds them to
 // |snippets|. Returns true on success, false if anything went wrong.
+// |remote_category_id| is only used if |content_suggestions_api| is true.
 bool AddSnippetsFromListValue(bool content_suggestions_api,
+                              int remote_category_id,
                               const base::ListValue& list,
                               NTPSnippet::PtrVector* snippets) {
   for (const auto& value : list) {
     const base::DictionaryValue* dict = nullptr;
     if (!value->GetAsDictionary(&dict)) {
       return false;
     }
 
     std::unique_ptr<NTPSnippet> snippet;
     if (content_suggestions_api) {
-      snippet = NTPSnippet::CreateFromContentSuggestionsDictionary(*dict);
+      snippet = NTPSnippet::CreateFromContentSuggestionsDictionary(
+          *dict, remote_category_id);
     } else {
       snippet = NTPSnippet::CreateFromChromeReaderDictionary(*dict);
     }
     if (!snippet) {
       return false;
     }
 
     snippets->push_back(std::move(snippet));
   }
   return true;
@@ skipping 445 matching lines @@
 
 bool NTPSnippetsFetcher::JsonToSnippets(const base::Value& parsed,
                                         FetchedCategoriesVector* categories) {
   const base::DictionaryValue* top_dict = nullptr;
   if (!parsed.GetAsDictionary(&top_dict)) {
     return false;
   }
 
   switch (fetch_api_) {
     case CHROME_READER_API: {
+      const int kUnusedRemoteCategoryId = -1;
       categories->push_back(FetchedCategory(
           category_factory_->FromKnownCategory(KnownCategories::ARTICLES)));
       const base::ListValue* recos = nullptr;
       return top_dict->GetList("recos", &recos) &&
-             AddSnippetsFromListValue(/* content_suggestions_api = */ false,
+             AddSnippetsFromListValue(/*content_suggestions_api=*/false,
+                                      kUnusedRemoteCategoryId,
                                       *recos, &categories->back().snippets);
     }
 
     case CHROME_CONTENT_SUGGESTIONS_API: {
       const base::ListValue* categories_value = nullptr;
       if (!top_dict->GetList("categories", &categories_value)) {
         return false;
       }
 
       for (const auto& v : *categories_value) {
         std::string utf8_title;
-        int category_id = -1;
+        int remote_category_id = -1;
         const base::DictionaryValue* category_value = nullptr;
         if (!(v->GetAsDictionary(&category_value) &&
               category_value->GetString("localizedTitle", &utf8_title) &&
-              category_value->GetInteger("id", &category_id) &&
-              (category_id > 0))) {
+              category_value->GetInteger("id", &remote_category_id) &&
+              (remote_category_id > 0))) {
           return false;
         }
 
         categories->push_back(FetchedCategory(
-            category_factory_->FromRemoteCategory(category_id)));
+            category_factory_->FromRemoteCategory(remote_category_id)));
         categories->back().localized_title = base::UTF8ToUTF16(utf8_title);
 
         const base::ListValue* suggestions = nullptr;
         if (!category_value->GetList("suggestions", &suggestions)) {
           // Absence of a list of suggestions is treated as an empty list, which
           // is permissible.
           continue;
         }
         if (!AddSnippetsFromListValue(
-                /* content_suggestions_api = */ true, *suggestions,
-                &categories->back().snippets)) {
+                /*content_suggestions_api=*/true, remote_category_id,
+                *suggestions, &categories->back().snippets)) {
           return false;
         }
       }
       return true;
     }
   }
   NOTREACHED();
   return false;
 }
 
@@ skipping 35 matching lines @@
   UMA_HISTOGRAM_ENUMERATION("NewTabPage.Snippets.FetchResult",
                             static_cast<int>(result),
                             static_cast<int>(FetchResult::RESULT_MAX));
 
   DVLOG(1) << "Fetch finished: " << last_status_;
   if (!snippets_available_callback_.is_null())
     snippets_available_callback_.Run(std::move(fetched_categories));
 }
 
 }  // namespace ntp_snippets