Add request type to FetchSuggestionsRequest.

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"
@@ skipping 90 matching lines @@
   return endpoint.empty() ? kChromeReaderServer : endpoint;
 }
 
 bool UsesChromeContentSuggestionsAPI(const GURL& endpoint) {
   if (endpoint == GURL(kChromeReaderServer)) {
     return false;
   } else if (endpoint != GURL(kContentSuggestionsServer) &&
              endpoint != GURL(kContentSuggestionsDevServer) &&
              endpoint != GURL(kContentSuggestionsAlphaServer)) {
     LOG(WARNING) << "Unknown value for " << kContentSuggestionsBackend << ": "
-      << "assuming chromecontentsuggestions-style API";
+                 << "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.
 bool AddSnippetsFromListValue(bool content_suggestions_api,
                               const base::ListValue& list,
                               NTPSnippet::PtrVector* snippets) {
   for (const auto& value : list) {
@@ skipping 42 matching lines @@
       token_service_(token_service),
       waiting_for_refresh_token_(false),
       url_request_context_getter_(url_request_context_getter),
       category_factory_(category_factory),
       parse_json_callback_(parse_json_callback),
       fetch_url_(GetFetchEndpoint()),
       fetch_api_(UsesChromeContentSuggestionsAPI(fetch_url_)
                      ? CHROME_CONTENT_SUGGESTIONS_API
                      : CHROME_READER_API),
       is_stable_channel_(is_stable_channel),
+      interactive_request_(false),
       tick_clock_(new base::DefaultTickClock()),
       request_throttler_(
           pref_service,
           RequestThrottler::RequestType::CONTENT_SUGGESTION_FETCHER),
       oauth_token_retried_(false),
       weak_ptr_factory_(this) {
   // Parse the variation parameters and set the defaults if missing.
   std::string personalization = variations::GetVariationParamValue(
       ntp_snippets::kStudyName, kPersonalizationName);
   if (personalization == kPersonalizationNonPersonalString) {
@@ skipping 47 matching lines @@
   if (UsesHostRestrictions() && hosts_.empty()) {
     FetchFinished(OptionalSnippets(), FetchResult::EMPTY_HOSTS,
                   /*extra_message=*/std::string());
     return;
   }
 
   locale_ = PosixLocaleFromBCP47Language(language_code);
   count_to_fetch_ = count;
 
   bool use_authentication = UsesAuthentication();
+  interactive_request_ = interactive_request;
 
   if (use_authentication && signin_manager_->IsAuthenticated()) {
     // Signed-in: get OAuth token --> fetch snippets.
     oauth_token_retried_ = false;
     StartTokenRequest();
   } else if (use_authentication && signin_manager_->AuthInProgress()) {
     // Currently signing in: wait for auth to finish (the refresh token) -->
     //     get OAuth token --> fetch snippets.
     if (!waiting_for_refresh_token_) {
       // Wait until we get a refresh token.
       waiting_for_refresh_token_ = true;
       token_service_->AddObserver(this);
     }
   } else {
     // Not signed in: fetch snippets (without authentication).
     FetchSnippetsNonAuthenticated();
   }
 }
 
 NTPSnippetsFetcher::RequestParams::RequestParams()
     : fetch_api(),
       obfuscated_gaia_id(),
       only_return_personalized_results(),
       user_locale(),
       host_restricts(),
-      count_to_fetch() {}
+      count_to_fetch(),
+      interactive_request() {}
 
 NTPSnippetsFetcher::RequestParams::~RequestParams() = default;
 
 std::string NTPSnippetsFetcher::RequestParams::BuildRequest() {
   auto request = base::MakeUnique<base::DictionaryValue>();
   switch (fetch_api) {
     case CHROME_READER_API: {
       auto content_params = base::MakeUnique<base::DictionaryValue>();
       content_params->SetBoolean("only_return_personalized_results",
                                  only_return_personalized_results);
@@ skipping 43 matching lines @@
     case CHROME_CONTENT_SUGGESTIONS_API: {
       if (!user_locale.empty()) {
         request->SetString("uiLanguage", user_locale);
       }
 
       auto regular_hosts = base::MakeUnique<base::ListValue>();
       for (const auto& host : host_restricts) {
         regular_hosts->AppendString(host);
       }
       request->Set("regularlyVisitedHostNames", std::move(regular_hosts));
+      request->SetString("priority", interactive_request
+                                         ? "USER_ACTION"
+                                         : "BACKGROUND_PREFETCH");
 
       auto excluded = base::MakeUnique<base::ListValue>();
       for (const auto& id : excluded_ids) {
         excluded->AppendString(id);
         if (excluded->GetSize() >= kMaxExcludedIds)
           break;
       }
       request->Set("excludedSuggestionIds", std::move(excluded));
 
       // TODO(sfiera): support authentication and personalization
@@ skipping 27 matching lines @@
   headers.SetHeader("Content-Type", "application/json; charset=UTF-8");
   // Add X-Client-Data header with experiment IDs from field trials.
   variations::AppendVariationHeaders(url,
                                      false,  // incognito
                                      false,  // uma_enabled
                                      &headers);
   url_fetcher_->SetExtraRequestHeaders(headers.ToString());
   url_fetcher_->SetUploadData("application/json", request);
   // Log the request for debugging network issues.
   VLOG(1) << "Sending a NTP snippets request to " << url << ":" << std::endl
-          << headers.ToString() << std::endl << request;
+          << headers.ToString() << std::endl
+          << request;
   // Fetchers are sometimes cancelled because a network change was detected.
   url_fetcher_->SetAutomaticallyRetryOnNetworkChanges(3);
   // Try to make fetching the files bit more robust even with poor connection.
   url_fetcher_->SetMaxRetriesOn5xx(3);
   url_fetcher_->Start();
 }
 
 bool NTPSnippetsFetcher::UsesHostRestrictions() const {
   return use_host_restriction_ &&
          !base::CommandLine::ForCurrentProcess()->HasSwitch(
@@ skipping 12 matching lines @@
                                : google_apis::GetNonStableAPIKey();
   GURL url(base::StringPrintf(kSnippetsServerNonAuthorizedFormat,
                               fetch_url_.spec().c_str(), key.c_str()));
 
   RequestParams params;
   params.fetch_api = fetch_api_;
   params.host_restricts =
       UsesHostRestrictions() ? hosts_ : std::set<std::string>();
   params.excluded_ids = excluded_ids_;
   params.count_to_fetch = count_to_fetch_;
+  params.interactive_request = interactive_request_;
   FetchSnippetsImpl(url, std::string(), params.BuildRequest());
 }
 
 void NTPSnippetsFetcher::FetchSnippetsAuthenticated(
     const std::string& account_id,
     const std::string& oauth_access_token) {
   RequestParams params;
   params.fetch_api = fetch_api_;
   params.obfuscated_gaia_id = account_id;
   params.only_return_personalized_results =
       personalization_ == Personalization::kPersonal;
   params.user_locale = locale_;
   params.host_restricts =
       UsesHostRestrictions() ? hosts_ : std::set<std::string>();
   params.excluded_ids = excluded_ids_;
   params.count_to_fetch = count_to_fetch_;
+  params.interactive_request = interactive_request_;
   // TODO(jkrcal, treib): Add unit-tests for authenticated fetches.
   FetchSnippetsImpl(fetch_url_,
                     base::StringPrintf(kAuthorizationRequestHeaderFormat,
                                        oauth_access_token.c_str()),
                     params.BuildRequest());
 }
 
 void NTPSnippetsFetcher::StartTokenRequest() {
   OAuth2TokenService::ScopeSet scopes;
   scopes.insert(fetch_api_ == CHROME_CONTENT_SUGGESTIONS_API
@@ skipping 69 matching lines @@
   } else if (source->GetResponseCode() != net::HTTP_OK) {
     // TODO(jkrcal): https://crbug.com/609084
     // We need to deal with the edge case again where the auth
     // token expires just before we send the request (in which case we need to
     // fetch a new auth token). We should extract that into a common class
     // instead of adding it to every single class that uses auth tokens.
     FetchFinished(
         OptionalSnippets(), FetchResult::HTTP_ERROR,
         /*extra_message=*/base::StringPrintf(" %d", source->GetResponseCode()));
   } else {
-    bool stores_result_to_string = source->GetResponseAsString(
-        &last_fetch_json_);
+    bool stores_result_to_string =
+        source->GetResponseAsString(&last_fetch_json_);
     DCHECK(stores_result_to_string);
 
-    parse_json_callback_.Run(
-        last_fetch_json_,
-        base::Bind(&NTPSnippetsFetcher::OnJsonParsed,
-                   weak_ptr_factory_.GetWeakPtr()),
-        base::Bind(&NTPSnippetsFetcher::OnJsonError,
-                   weak_ptr_factory_.GetWeakPtr()));
+    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) {
   const base::DictionaryValue* top_dict = nullptr;
   if (!parsed.GetAsDictionary(&top_dict)) {
     return false;
   }
 
@@ skipping 49 matching lines @@
                   /*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) {
-  LOG(WARNING) << "Received invalid JSON (" << error << "): "
-               << last_fetch_json_;
+  LOG(WARNING) << "Received invalid JSON (" << error
+               << "): " << last_fetch_json_;
   FetchFinished(
       OptionalSnippets(), FetchResult::JSON_PARSE_ERROR,
       /*extra_message=*/base::StringPrintf(" (error %s)", error.c_str()));
 }
 
 void NTPSnippetsFetcher::FetchFinished(OptionalSnippets snippets,
                                        FetchResult result,
                                        const std::string& extra_message) {
   DCHECK(result == FetchResult::SUCCESS || !snippets);
   last_status_ = FetchResultToString(result) + extra_message;
 
   // If the result is EMPTY_HOSTS or OAUTH_TOKEN_ERROR, we didn't actually send
   // a network request, so don't record FetchTime in those cases.
   if (result != FetchResult::EMPTY_HOSTS &&
       result != FetchResult::OAUTH_TOKEN_ERROR) {
     UMA_HISTOGRAM_TIMES("NewTabPage.Snippets.FetchTime",
                         tick_clock_->NowTicks() - fetch_start_time_);
   }
   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