Support server-provided category names.

components/ntp_snippets/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/ntp_snippets_fetcher.h"
 
 #include <stdlib.h>
 
 #include "base/command_line.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/json/json_writer.h"
 #include "base/memory/ptr_util.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/metrics/sparse_histogram.h"
 #include "base/path_service.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
+#include "base/strings/utf_string_conversions.h"
 #include "base/time/default_tick_clock.h"
 #include "base/values.h"
 #include "components/data_use_measurement/core/data_use_user_data.h"
 #include "components/ntp_snippets/category_factory.h"
 #include "components/ntp_snippets/ntp_snippets_constants.h"
 #include "components/ntp_snippets/switches.h"
 #include "components/signin/core/browser/profile_oauth2_token_service.h"
 #include "components/signin/core/browser/signin_manager.h"
 #include "components/signin/core/browser/signin_manager_base.h"
 #include "components/variations/net/variations_http_headers.h"
@@ skipping 137 matching lines @@
   // Translate the input to a posix locale.
   uloc_forLanguageTag(language_code.c_str(), locale, ULOC_FULLNAME_CAPACITY,
                       nullptr, &error);
   DLOG_IF(WARNING, U_ZERO_ERROR != error)
       << "Error in translating language code to a locale string: " << error;
   return locale;
 }
 
 }  // namespace
 
+NTPSnippetsFetcher::FetchedCategory::FetchedCategory(Category c)
+    : category(c) {}
+
+NTPSnippetsFetcher::FetchedCategory::FetchedCategory(FetchedCategory&&) =
+    default;
+NTPSnippetsFetcher::FetchedCategory::~FetchedCategory() = default;
+NTPSnippetsFetcher::FetchedCategory& NTPSnippetsFetcher::FetchedCategory::
+operator=(FetchedCategory&&) = default;
+
 NTPSnippetsFetcher::NTPSnippetsFetcher(
     SigninManagerBase* signin_manager,
     OAuth2TokenService* token_service,
     scoped_refptr<URLRequestContextGetter> url_request_context_getter,
     PrefService* pref_service,
     CategoryFactory* category_factory,
     const ParseJSONCallback& parse_json_callback,
     bool is_stable_channel)
     : OAuth2TokenService::Consumer("ntp_snippets"),
       signin_manager_(signin_manager),
@@ skipping 369 matching lines @@
 
     parse_json_callback_.Run(last_fetch_json_,
                              base::Bind(&NTPSnippetsFetcher::OnJsonParsed,
                                         weak_ptr_factory_.GetWeakPtr()),
                              base::Bind(&NTPSnippetsFetcher::OnJsonError,
                                         weak_ptr_factory_.GetWeakPtr()));
   }
 }
 
 bool NTPSnippetsFetcher::JsonToSnippets(const base::Value& parsed,
-                                        NTPSnippet::CategoryMap* snippets) {
+                                        FetchedCategoriesVector* categories) {
   const base::DictionaryValue* top_dict = nullptr;
   if (!parsed.GetAsDictionary(&top_dict)) {
     return false;
   }
 
   switch (fetch_api_) {
     case CHROME_READER_API: {
-      Category category =
-          category_factory_->FromKnownCategory(KnownCategories::ARTICLES);
-      NTPSnippet::PtrVector* articles = &(*snippets)[category];
+      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,
-                                      *recos, articles);
+                                      *recos, &categories->back().snippets);
     }
 
     case CHROME_CONTENT_SUGGESTIONS_API: {
-      const base::ListValue* categories = nullptr;
-      if (!top_dict->GetList("categories", &categories)) {
+      const base::ListValue* categories_value = nullptr;
+      if (!top_dict->GetList("categories", &categories_value)) {
         return false;
       }
 
-      for (const auto& v : *categories) {
+      for (const auto& v : *categories_value) {
+        std::string utf8_title;
         int 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))) {
           return false;
         }
-        Category category = category_factory_->FromRemoteCategory(category_id);
+
+        categories->push_back(FetchedCategory(
+            category_factory_->FromRemoteCategory(category_id)));
+        categories->back().localized_title = base::UTF8ToUTF16(utf8_title);
+
         const base::ListValue* suggestions = nullptr;
-        NTPSnippet::PtrVector* articles = &(*snippets)[category];
         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, articles)) {
+                /* content_suggestions_api = */ true, *suggestions,
+                &categories->back().snippets)) {
           return false;
         }
       }
       return true;
     }
   }
   NOTREACHED();
   return false;
 }
 
 void NTPSnippetsFetcher::OnJsonParsed(std::unique_ptr<base::Value> parsed) {
-  NTPSnippet::CategoryMap snippets;
-  if (JsonToSnippets(*parsed, &snippets)) {
-    FetchFinished(OptionalSnippets(std::move(snippets)), FetchResult::SUCCESS,
+  FetchedCategoriesVector categories;
+  if (JsonToSnippets(*parsed, &categories)) {
+    FetchFinished(OptionalSnippets(std::move(categories)), FetchResult::SUCCESS,
                   /*extra_message=*/std::string());
   } else {
     LOG(WARNING) << "Received invalid snippets: " << last_fetch_json_;
     FetchFinished(OptionalSnippets(),
                   FetchResult::INVALID_SNIPPET_CONTENT_ERROR,
                   /*extra_message=*/std::string());
   }
 }
 
 void NTPSnippetsFetcher::OnJsonError(const std::string& error) {
@@ skipping 19 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(snippets));
 }
 
 }  // namespace ntp_snippets