RemoteSuggestionsFetcher: Remove ChromeReader integration

components/ntp_snippets/remote/remote_suggestions_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/remote_suggestions_fetcher.h"
 
 #include <cstdlib>
 #include <utility>
 
 #include "base/files/file_path.h"
@@ skipping 22 matching lines @@
 
 using net::URLFetcher;
 using net::URLRequestContextGetter;
 using net::HttpRequestHeaders;
 using net::URLRequestStatus;
 using translate::LanguageModel;
 
 namespace ntp_snippets {
 
 using internal::JsonRequest;
-using internal::FetchAPI;
 using internal::FetchResult;
 
 namespace {
 
-const char kChromeReaderApiScope[] =
-    "https://www.googleapis.com/auth/webhistory";
 const char kContentSuggestionsApiScope[] =
     "https://www.googleapis.com/auth/chrome-content-suggestions";
 const char kSnippetsServerNonAuthorizedFormat[] = "%s?key=%s";
 const char kAuthorizationRequestHeaderFormat[] = "Bearer %s";
 
 // Variation parameter for chrome-content-suggestions backend.
 const char kContentSuggestionsBackend[] = "content_suggestions_backend";
 
 const int kFetchTimeHistogramResolution = 5;
 
@@ skipping 37 matching lines @@
     case FetchResult::INVALID_SNIPPET_CONTENT_ERROR:
     case FetchResult::JSON_PARSE_ERROR:
       return Status(StatusCode::TEMPORARY_ERROR, FetchResultToString(result));
     case FetchResult::RESULT_MAX:
       break;
   }
   NOTREACHED();
   return Status(StatusCode::PERMANENT_ERROR, std::string());
 }
 
-bool UsesChromeContentSuggestionsAPI(const GURL& endpoint) {
-  if (endpoint == kChromeReaderServer) {
-    return false;
-  }
-
-  if (endpoint != kContentSuggestionsServer &&
-      endpoint != kContentSuggestionsStagingServer &&
-      endpoint != kContentSuggestionsAlphaServer) {
-    LOG(WARNING) << "Unknown value for " << kContentSuggestionsBackend << ": "
-                 << endpoint << "; assuming chromecontentsuggestions-style API";
-  }
-  return true;
-}
-
 // Creates suggestions from dictionary values in |list| and adds them to
 // |suggestions|. Returns true on success, false if anything went wrong.
 // |remote_category_id| is only used if |content_suggestions_api| is true.
 bool AddSuggestionsFromListValue(bool content_suggestions_api,
                                  int remote_category_id,
                                  const base::ListValue& list,
                                  RemoteSuggestion::PtrVector* suggestions,
                                  const base::Time& fetch_time) {
   for (const auto& value : list) {
     const base::DictionaryValue* dict = nullptr;
@@ skipping 129 matching lines @@
     const GURL& api_endpoint,
     const std::string& api_key,
     const UserClassifier* user_classifier)
     : OAuth2TokenService::Consumer("ntp_snippets"),
       signin_manager_(signin_manager),
       token_service_(token_service),
       url_request_context_getter_(std::move(url_request_context_getter)),
       language_model_(language_model),
       parse_json_callback_(parse_json_callback),
       fetch_url_(api_endpoint),
-      fetch_api_(UsesChromeContentSuggestionsAPI(fetch_url_)
-                     ? FetchAPI::CHROME_CONTENT_SUGGESTIONS_API
-                     : FetchAPI::CHROME_READER_API),
       api_key_(api_key),
       clock_(new base::DefaultClock()),
       user_classifier_(user_classifier) {}
 
 RemoteSuggestionsFetcher::~RemoteSuggestionsFetcher() {
   if (waiting_for_refresh_token_) {
     token_service_->RemoveObserver(this);
   }
 }
 
 void RemoteSuggestionsFetcher::FetchSnippets(
     const RequestParams& params,
     SnippetsAvailableCallback callback) {
   if (!params.interactive_request) {
     UMA_HISTOGRAM_SPARSE_SLOWLY(
         "NewTabPage.Snippets.FetchTimeLocal",
         GetMinuteOfTheDay(/*local_time=*/true,
                           /*reduced_resolution=*/true, clock_.get()));
     UMA_HISTOGRAM_SPARSE_SLOWLY(
         "NewTabPage.Snippets.FetchTimeUTC",
         GetMinuteOfTheDay(/*local_time=*/false,
                           /*reduced_resolution=*/true, clock_.get()));
   }
 
   JsonRequest::Builder builder;
-  builder.SetFetchAPI(fetch_api_)
-      .SetFetchAPI(fetch_api_)
-      .SetLanguageModel(language_model_)
+  builder.SetLanguageModel(language_model_)
       .SetParams(params)
       .SetParseJsonCallback(parse_json_callback_)
       .SetClock(clock_.get())
       .SetUrlRequestContextGetter(url_request_context_getter_)
       .SetUserClassifier(*user_classifier_);
 
   if (signin_manager_->IsAuthenticated()) {
     // Signed-in: get OAuth token --> fetch suggestions.
     oauth_token_retried_ = false;
     pending_requests_.emplace(std::move(builder), std::move(callback));
@@ skipping 47 matching lines @@
     SnippetsAvailableCallback callback) {
   std::unique_ptr<JsonRequest> request = builder.Build();
   JsonRequest* raw_request = request.get();
   raw_request->Start(base::BindOnce(&RemoteSuggestionsFetcher::JsonRequestDone,
                                     base::Unretained(this), std::move(request),
                                     std::move(callback)));
 }
 
 void RemoteSuggestionsFetcher::StartTokenRequest() {
   OAuth2TokenService::ScopeSet scopes;
-  scopes.insert(fetch_api_ == FetchAPI::CHROME_CONTENT_SUGGESTIONS_API
-                    ? kContentSuggestionsApiScope
-                    : kChromeReaderApiScope);
+  scopes.insert(kContentSuggestionsApiScope);
   oauth_request_ = token_service_->StartRequest(
       signin_manager_->GetAuthenticatedAccountId(), scopes, this);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // OAuth2TokenService::Consumer overrides
 void RemoteSuggestionsFetcher::OnGetTokenSuccess(
     const OAuth2TokenService::Request* request,
     const std::string& access_token,
     const base::Time& expiration_time) {
@@ skipping 69 matching lines @@
   last_fetch_json_ = request->GetResponseString();
 
   UMA_HISTOGRAM_TIMES("NewTabPage.Snippets.FetchTime",
                       request->GetFetchDuration());
 
   if (!result) {
     FetchFinished(OptionalFetchedCategories(), std::move(callback), status_code,
                   error_details);
     return;
   }
+
   FetchedCategoriesVector categories;
-
   if (!JsonToSnippets(*result, &categories, fetch_time)) {
     LOG(WARNING) << "Received invalid snippets: " << last_fetch_json_;
     FetchFinished(OptionalFetchedCategories(), std::move(callback),
                   FetchResult::INVALID_SNIPPET_CONTENT_ERROR, std::string());
     return;
   }
   // Filter out unwanted categories if necessary.
   // TODO(fhorschig): As soon as the server supports filtering by category,
   // adjust the request instead of over-fetching and filtering here.
   FilterCategories(&categories, request->exclusive_category());
@@ skipping 23 matching lines @@
 
 bool RemoteSuggestionsFetcher::JsonToSnippets(
     const base::Value& parsed,
     FetchedCategoriesVector* categories,
     const base::Time& fetch_time) {
   const base::DictionaryValue* top_dict = nullptr;
   if (!parsed.GetAsDictionary(&top_dict)) {
     return false;
   }
 
-  switch (fetch_api_) {
-    case FetchAPI::CHROME_READER_API: {
-      const int kUnusedRemoteCategoryId = -1;
-      categories->push_back(FetchedCategory(
-          Category::FromKnownCategory(KnownCategories::ARTICLES),
-          BuildArticleCategoryInfo(base::nullopt)));
+  const base::ListValue* categories_value = nullptr;
+  if (!top_dict->GetList("categories", &categories_value)) {
+    return false;
+  }
 
-      const base::ListValue* recos = nullptr;
-      return top_dict->GetList("recos", &recos) &&
-             AddSuggestionsFromListValue(
-                 /*content_suggestions_api=*/false, kUnusedRemoteCategoryId,
-                 *recos, &categories->back().suggestions, fetch_time);
+  for (const auto& v : *categories_value) {
+    std::string utf8_title;
+    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", &remote_category_id) &&
+          (remote_category_id > 0))) {
+      return false;
     }
 
-    case FetchAPI::CHROME_CONTENT_SUGGESTIONS_API: {
-      const base::ListValue* categories_value = nullptr;
-      if (!top_dict->GetList("categories", &categories_value)) {
+    RemoteSuggestion::PtrVector suggestions;
+    const base::ListValue* suggestions_list = nullptr;
+    // Absence of a list of suggestions is treated as an empty list, which
+    // is permissible.
+    if (category_value->GetList("suggestions", &suggestions_list)) {
+      if (!AddSuggestionsFromListValue(
+              /*content_suggestions_api=*/true, remote_category_id,
+              *suggestions_list, &suggestions, fetch_time)) {
         return false;
       }
+    }
+    Category category = Category::FromRemoteCategory(remote_category_id);
+    if (category.IsKnownCategory(KnownCategories::ARTICLES)) {
+      categories->push_back(FetchedCategory(
+          category, BuildArticleCategoryInfo(base::UTF8ToUTF16(utf8_title))));
+    } else {
+      // TODO(tschumann): Right now, the backend does not yet populate this
+      // field. Make it mandatory once the backends provide it.
+      bool allow_fetching_more_results = false;
+      category_value->GetBoolean("allowFetchingMoreResults",
+                                 &allow_fetching_more_results);
+      categories->push_back(FetchedCategory(
+          category, BuildRemoteCategoryInfo(base::UTF8ToUTF16(utf8_title),
+                                            allow_fetching_more_results)));
+    }
+    categories->back().suggestions = std::move(suggestions);
+  }
 
-      for (const auto& v : *categories_value) {
-        std::string utf8_title;
-        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", &remote_category_id) &&
-              (remote_category_id > 0))) {
-          return false;
-        }
-
-        RemoteSuggestion::PtrVector suggestions;
-        const base::ListValue* suggestions_list = nullptr;
-        // Absence of a list of suggestions is treated as an empty list, which
-        // is permissible.
-        if (category_value->GetList("suggestions", &suggestions_list)) {
-          if (!AddSuggestionsFromListValue(
-                  /*content_suggestions_api=*/true, remote_category_id,
-                  *suggestions_list, &suggestions, fetch_time)) {
-            return false;
-          }
-        }
-        Category category = Category::FromRemoteCategory(remote_category_id);
-        if (category.IsKnownCategory(KnownCategories::ARTICLES)) {
-          categories->push_back(FetchedCategory(
-              category,
-              BuildArticleCategoryInfo(base::UTF8ToUTF16(utf8_title))));
-        } else {
-          // TODO(tschumann): Right now, the backend does not yet populate this
-          // field. Make it mandatory once the backends provide it.
-          bool allow_fetching_more_results = false;
-          category_value->GetBoolean("allowFetchingMoreResults",
-                                     &allow_fetching_more_results);
-          categories->push_back(FetchedCategory(
-              category, BuildRemoteCategoryInfo(base::UTF8ToUTF16(utf8_title),
-                                                allow_fetching_more_results)));
-        }
-        categories->back().suggestions = std::move(suggestions);
-      }
-      return true;
-    }
-  }
-  NOTREACHED();
-  return false;
+  return true;
 }
 
 }  // namespace ntp_snippets