[Doodle] Record UMA for DoodleConfig download outcome and time

components/doodle/doodle_service.cc

 // Copyright 2017 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/doodle/doodle_service.h"
 
 #include <utility>
 
 #include "base/bind.h"
+#include "base/metrics/histogram_macros.h"
 #include "base/time/time.h"
 #include "base/values.h"
 #include "components/doodle/pref_names.h"
 #include "components/prefs/pref_registry.h"
 #include "components/prefs/pref_registry_simple.h"
 #include "components/prefs/pref_service.h"
 
 namespace doodle {
 
 // static
 void DoodleService::RegisterProfilePrefs(PrefRegistrySimple* pref_registry) {
   pref_registry->RegisterDictionaryPref(prefs::kCachedConfig,
                                         new base::DictionaryValue(),
                                         PrefRegistry::LOSSY_PREF);
   pref_registry->RegisterInt64Pref(prefs::kCachedConfigExpiry, 0,
                                    PrefRegistry::LOSSY_PREF);
 }
 
 DoodleService::DoodleService(PrefService* pref_service,
                              std::unique_ptr<DoodleFetcher> fetcher,
                              std::unique_ptr<base::OneShotTimer> expiry_timer,
-                             std::unique_ptr<base::Clock> clock)
+                             std::unique_ptr<base::Clock> clock,
+                             std::unique_ptr<base::TickClock> tick_clock)
     : pref_service_(pref_service),
       fetcher_(std::move(fetcher)),
       expiry_timer_(std::move(expiry_timer)),
-      clock_(std::move(clock)) {
+      clock_(std::move(clock)),
+      tick_clock_(std::move(tick_clock)) {
   DCHECK(pref_service_);
   DCHECK(fetcher_);
   DCHECK(expiry_timer_);
   DCHECK(clock_);
+  DCHECK(tick_clock_);
 
   base::Time expiry_date = base::Time::FromInternalValue(
       pref_service_->GetInt64(prefs::kCachedConfigExpiry));
   base::Optional<DoodleConfig> config = DoodleConfig::FromDictionary(
       *pref_service_->GetDictionary(prefs::kCachedConfig), base::nullopt);
-  UpdateCachedConfig(expiry_date - clock_->Now(), config);
+  DoodleState state =
+      config.has_value() ? DoodleState::AVAILABLE : DoodleState::NO_DOODLE;
+  UpdateCachedConfig(state, expiry_date - clock_->Now(), config);
 }
 
 DoodleService::~DoodleService() = default;
 
 void DoodleService::Shutdown() {}
 
 void DoodleService::AddObserver(Observer* observer) {
   observers_.AddObserver(observer);
 }
 
 void DoodleService::RemoveObserver(Observer* observer) {
   observers_.RemoveObserver(observer);
 }
 
 void DoodleService::Refresh() {
-  fetcher_->FetchDoodle(
-      base::BindOnce(&DoodleService::DoodleFetched, base::Unretained(this)));
+  fetcher_->FetchDoodle(base::BindOnce(&DoodleService::DoodleFetched,
+                                       base::Unretained(this),
+                                       tick_clock_->NowTicks()));
+}
+
+// static
+bool DoodleService::DownloadOutcomeIsSuccess(DownloadOutcome outcome) {
+  switch (outcome) {
+    case OUTCOME_NEW_DOODLE:
+    case OUTCOME_REVALIDATED_DOODLE:
+    case OUTCOME_CHANGED_DOODLE:
+    case OUTCOME_NO_DOODLE:
+      return true;
+    case OUTCOME_EXPIRED:
+    case OUTCOME_DOWNLOAD_ERROR:
+    case OUTCOME_PARSING_ERROR:
+      return false;
+    case OUTCOME_COUNT:
+      NOTREACHED();
+  }
+  return false;
+}
+
+// static
+void DoodleService::RecordDownloadMetrics(DownloadOutcome outcome,
+                                          base::TimeDelta download_time) {
+  UMA_HISTOGRAM_ENUMERATION("Doodle.ConfigDownloadOutcome", outcome,
+                            OUTCOME_COUNT);
+
+  if (DownloadOutcomeIsSuccess(outcome)) {
+    UMA_HISTOGRAM_MEDIUM_TIMES("Doodle.ConfigDownloadTime", download_time);
+  }
 }
 
 void DoodleService::DoodleFetched(
+    base::TimeTicks start_time,
     DoodleState state,
     base::TimeDelta time_to_live,
     const base::Optional<DoodleConfig>& doodle_config) {
-  UpdateCachedConfig(time_to_live, doodle_config);
+  base::TimeDelta download_time = tick_clock_->NowTicks() - start_time;
+  DownloadOutcome outcome =
+      UpdateCachedConfig(state, time_to_live, doodle_config);
+  RecordDownloadMetrics(outcome, download_time);
 }
 
-void DoodleService::UpdateCachedConfig(
+DoodleService::DownloadOutcome DoodleService::UpdateCachedConfig(
+    DoodleState state,
     base::TimeDelta time_to_live,
     const base::Optional<DoodleConfig>& doodle_config) {
   // Handle the case where the new config is already expired.
   bool expired = time_to_live <= base::TimeDelta();
   const base::Optional<DoodleConfig>& new_config =
       expired ? base::nullopt : doodle_config;
 
+  DownloadOutcome outcome = OUTCOME_COUNT;
+
   // If the config changed, update our cache and notify observers.
   // Note that this checks both for existence changes as well as changes of the
   // configs themselves.
   if (cached_config_ != new_config) {
+    bool had_config_before = cached_config_.has_value();
+
     cached_config_ = new_config;
 
     if (cached_config_.has_value()) {
+      outcome = had_config_before ? OUTCOME_CHANGED_DOODLE : OUTCOME_NEW_DOODLE;
+
       pref_service_->Set(prefs::kCachedConfig, *cached_config_->ToDictionary());
       base::Time expiry_date = clock_->Now() + time_to_live;
       pref_service_->SetInt64(prefs::kCachedConfigExpiry,
                               expiry_date.ToInternalValue());
     } else {
+      outcome = OUTCOME_NO_DOODLE;
+
       pref_service_->ClearPref(prefs::kCachedConfig);
       pref_service_->ClearPref(prefs::kCachedConfigExpiry);
     }
 
     for (auto& observer : observers_) {
       observer.OnDoodleConfigUpdated(cached_config_);
     }
+  } else {
+    outcome = cached_config_.has_value() ? OUTCOME_REVALIDATED_DOODLE
+                                         : OUTCOME_NO_DOODLE;
+  }
+
+  DCHECK(outcome != OUTCOME_COUNT);
+  // Determine the final outcome. ERROR or EXPIRED override NO_DOODLE.
+  switch (state) {
+    case DoodleState::AVAILABLE:
+    case DoodleState::NO_DOODLE:
+      if (expired) {
+        outcome = OUTCOME_EXPIRED;
+      }
+      break;
+
+    case DoodleState::DOWNLOAD_ERROR:
+      outcome = OUTCOME_DOWNLOAD_ERROR;
+      break;
+
+    case DoodleState::PARSING_ERROR:
+      outcome = OUTCOME_PARSING_ERROR;
+      break;
   }
 
   // Even if the configs are identical, the time-to-live might have changed.
   // (Re-)schedule the cache expiry.
   if (cached_config_.has_value()) {
     expiry_timer_->Start(
         FROM_HERE, time_to_live,
         base::Bind(&DoodleService::DoodleExpired, base::Unretained(this)));
   } else {
     expiry_timer_->Stop();
   }
+
+  return outcome;
 }
 
 void DoodleService::DoodleExpired() {
   DCHECK(cached_config_.has_value());
-  UpdateCachedConfig(base::TimeDelta(), base::nullopt);
+  UpdateCachedConfig(DoodleState::NO_DOODLE, base::TimeDelta(), base::nullopt);
 }
 
 }  // namespace doodle