[remote suggestions] Attach the fetch time to RemoteSnippets, ContentSnippets and SnippetArticle

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"
 #include "base/files/file_util.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/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
-#include "base/time/default_tick_clock.h"
+#include "base/time/default_clock.h"
 #include "base/time/time.h"
 #include "base/values.h"
 #include "components/data_use_measurement/core/data_use_user_data.h"
 #include "components/ntp_snippets/category.h"
 #include "components/ntp_snippets/features.h"
 #include "components/ntp_snippets/ntp_snippets_constants.h"
 #include "components/ntp_snippets/remote/request_params.h"
 #include "components/ntp_snippets/user_classifier.h"
 #include "components/signin/core/browser/signin_manager.h"
 #include "components/signin/core/browser/signin_manager_base.h"
@@ skipping 100 matching lines @@
   }
   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) {
+                                 RemoteSuggestion::PtrVector* suggestions,
+                                 const base::Time& fetch_time) {
   for (const auto& value : list) {
     const base::DictionaryValue* dict = nullptr;
     if (!value->GetAsDictionary(&dict)) {
       return false;
     }
 
     std::unique_ptr<RemoteSuggestion> suggestion;
     if (content_suggestions_api) {
       suggestion = RemoteSuggestion::CreateFromContentSuggestionsDictionary(
-          *dict, remote_category_id);
+          *dict, remote_category_id, fetch_time);
     } else {
-      suggestion = RemoteSuggestion::CreateFromChromeReaderDictionary(*dict);
+      suggestion =
+          RemoteSuggestion::CreateFromChromeReaderDictionary(*dict, fetch_time);
     }
     if (!suggestion) {
       return false;
     }
 
     suggestions->push_back(std::move(suggestion));
   }
   return true;
 }
 
-int GetMinuteOfTheDay(bool local_time, bool reduced_resolution) {
-  base::Time now(base::Time::Now());
+int GetMinuteOfTheDay(bool local_time,
+                      bool reduced_resolution,
+                      base::Clock* clock) {
+  base::Time now(clock->Now());
   base::Time::Exploded now_exploded{};
   local_time ? now.LocalExplode(&now_exploded) : now.UTCExplode(&now_exploded);
   int now_minute = reduced_resolution
                        ? now_exploded.minute / kFetchTimeHistogramResolution *
                              kFetchTimeHistogramResolution
                        : now_exploded.minute;
   return now_exploded.hour * 60 + now_minute;
 }
 
 // The response from the backend might include suggestions from multiple
@@ skipping 74 matching lines @@
       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_(GetFetchEndpoint()),
       fetch_api_(UsesChromeContentSuggestionsAPI(fetch_url_)
                      ? FetchAPI::CHROME_CONTENT_SUGGESTIONS_API
                      : FetchAPI::CHROME_READER_API),
       api_key_(api_key),
-      tick_clock_(new base::DefaultTickClock()),
+      clock_(new base::DefaultClock()),
       user_classifier_(user_classifier),
       request_throttler_rare_ntp_user_(
           pref_service,
           RequestThrottler::RequestType::
               CONTENT_SUGGESTION_FETCHER_RARE_NTP_USER),
       request_throttler_active_ntp_user_(
           pref_service,
           RequestThrottler::RequestType::
               CONTENT_SUGGESTION_FETCHER_ACTIVE_NTP_USER),
       request_throttler_active_suggestions_consumer_(
@@ skipping 14 matching lines @@
   if (!DemandQuotaForRequest(params.interactive_request)) {
     FetchFinished(OptionalFetchedCategories(), std::move(callback),
                   params.interactive_request
                       ? FetchResult::INTERACTIVE_QUOTA_ERROR
                       : FetchResult::NON_INTERACTIVE_QUOTA_ERROR,
                   /*error_details=*/std::string());
     return;
   }
 
   if (!params.interactive_request) {
-    UMA_HISTOGRAM_SPARSE_SLOWLY("NewTabPage.Snippets.FetchTimeLocal",
-                                GetMinuteOfTheDay(/*local_time=*/true,
-                                                  /*reduced_resolution=*/true));
-    UMA_HISTOGRAM_SPARSE_SLOWLY("NewTabPage.Snippets.FetchTimeUTC",
-                                GetMinuteOfTheDay(/*local_time=*/false,
-                                                  /*reduced_resolution=*/true));
+    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_)
       .SetParams(params)
       .SetParseJsonCallback(parse_json_callback_)
-      .SetTickClock(tick_clock_.get())
+      .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));
     StartTokenRequest();
   } else if (signin_manager_->AuthInProgress()) {
     // Currently signing in: wait for auth to finish (the refresh token) -->
@@ skipping 117 matching lines @@
   StartTokenRequest();
 }
 
 void RemoteSuggestionsFetcher::JsonRequestDone(
     std::unique_ptr<JsonRequest> request,
     SnippetsAvailableCallback callback,
     std::unique_ptr<base::Value> result,
     FetchResult status_code,
     const std::string& error_details) {
   DCHECK(request);
+  // Record the time when request for fetching remote content snippets finished.
+  const base::Time fetch_time = clock_->Now();
+
   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)) {
+
+  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 15 matching lines @@
                             static_cast<int>(FetchResult::RESULT_MAX));
 
   DVLOG(1) << "Fetch finished: " << last_status_;
 
   std::move(callback).Run(FetchResultToStatus(fetch_result),
                           std::move(categories));
 }
 
 bool RemoteSuggestionsFetcher::JsonToSnippets(
     const base::Value& parsed,
-    FetchedCategoriesVector* categories) {
+    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* recos = nullptr;
       return top_dict->GetList("recos", &recos) &&
-             AddSuggestionsFromListValue(/*content_suggestions_api=*/false,
-                                         kUnusedRemoteCategoryId, *recos,
-                                         &categories->back().suggestions);
+             AddSuggestionsFromListValue(
+                 /*content_suggestions_api=*/false, kUnusedRemoteCategoryId,
+                 *recos, &categories->back().suggestions, fetch_time);
     }
 
     case FetchAPI::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 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)) {
+                  *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
@@ skipping 24 matching lines @@
           interactive_request);
     case UserClassifier::UserClass::ACTIVE_SUGGESTIONS_CONSUMER:
       return request_throttler_active_suggestions_consumer_
           .DemandQuotaForRequest(interactive_request);
   }
   NOTREACHED();
   return false;
 }
 
 }  // namespace ntp_snippets