Define a few simple UMA metrics for the component updater.

components/component_updater/component_updater_service.cc

 // Copyright 2014 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/component_updater/component_updater_service.h"
 
 #include <algorithm>
 #include <map>
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/memory/scoped_ptr.h"
+#include "base/metrics/histogram_macros.h"
 #include "base/sequenced_task_runner.h"
 #include "base/single_thread_task_runner.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/threading/sequenced_worker_pool.h"
 #include "base/threading/thread_checker.h"
+#include "base/time/time.h"
 #include "base/timer/timer.h"
 #include "components/component_updater/component_updater_service_internal.h"
 #include "components/component_updater/timer.h"
 #include "components/update_client/configurator.h"
 #include "components/update_client/crx_update_item.h"
 #include "components/update_client/update_client.h"
 #include "components/update_client/utils.h"
 #include "url/gurl.h"
 
 using CrxInstaller = update_client::CrxInstaller;
 using UpdateClient = update_client::UpdateClient;
 
+namespace {
+
+enum UpdateType {
+  UPDATE_TYPE_MANUAL = 0,
+  UPDATE_TYPE_AUTOMATIC,
+  UPDATE_TYPE_COUNT,
+};
+
+}  // namespace
+
 namespace component_updater {
 
 CrxUpdateService::CrxUpdateService(
     const scoped_refptr<Configurator>& config,
     const scoped_refptr<UpdateClient>& update_client)
     : config_(config),
       update_client_(update_client),
       blocking_task_runner_(config->GetSequencedTaskRunner()) {
   AddObserver(this);
 }
@@ skipping 180 matching lines @@
     if (delta < base::TimeDelta::FromSeconds(config_->OnDemandDelay()))
       return false;
   }
 
   return OnDemandUpdateInternal(id);
 }
 
 bool CrxUpdateService::OnDemandUpdateInternal(const std::string& id) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
+  UMA_HISTOGRAM_ENUMERATION("ComponentUpdater.Calls", UPDATE_TYPE_MANUAL,
+                            UPDATE_TYPE_COUNT);
+
   update_client_->Install(
       id, base::Bind(&CrxUpdateService::OnUpdate, base::Unretained(this)),
-      base::Bind(&CrxUpdateService::OnUpdateComplete, base::Unretained(this)));
+      base::Bind(&CrxUpdateService::OnUpdateComplete, base::Unretained(this),
+                 base::TimeTicks::Now()));
 
   return true;
 }
 
 bool CrxUpdateService::CheckForUpdates() {
   DCHECK(thread_checker_.CalledOnValidThread());
+
+  UMA_HISTOGRAM_ENUMERATION("ComponentUpdater.Calls", UPDATE_TYPE_AUTOMATIC,
+                            UPDATE_TYPE_COUNT);
+
   std::vector<std::string> ids;
   for (const auto id : components_order_) {
     DCHECK(components_.find(id) != components_.end());
     ids.push_back(id);
   }
 
   update_client_->Update(
       ids, base::Bind(&CrxUpdateService::OnUpdate, base::Unretained(this)),
-      base::Bind(&CrxUpdateService::OnUpdateComplete, base::Unretained(this)));
+      base::Bind(&CrxUpdateService::OnUpdateComplete, base::Unretained(this),
+                 base::TimeTicks::Now()));
 
   return true;
 }
 
 scoped_refptr<base::SequencedTaskRunner>
 CrxUpdateService::GetSequencedTaskRunner() {
   DCHECK(thread_checker_.CalledOnValidThread());
   return blocking_task_runner_;
 }
 
@@ skipping 23 matching lines @@
   DCHECK(components->empty());
 
   for (const auto& id : ids) {
     const auto registered_component(GetComponent(id));
     if (registered_component) {
       components->push_back(*registered_component);
     }
   }
 }
 
-void CrxUpdateService::OnUpdateComplete(int error) {
+void CrxUpdateService::OnUpdateComplete(const base::TimeTicks& start_time,
+                                        int error) {
   DCHECK(thread_checker_.CalledOnValidThread());
   VLOG(1) << "Update completed with error " << error;
 
+  UMA_HISTOGRAM_BOOLEAN("ComponentUpdater.UpdateCompleteResult", error != 0);
+  UMA_HISTOGRAM_LONG_TIMES_100("ComponentUpdater.UpdateCompleteTime",
+                               base::TimeTicks::Now() - start_time);
+
   for (const auto id : components_pending_unregistration_) {
     if (!update_client_->IsUpdating(id)) {
       const auto component = GetComponent(id);
       if (component)
         DoUnregisterComponent(*component);
     }
   }
 }
 
 void CrxUpdateService::OnEvent(Events event, const std::string& id) {
@@ skipping 35 matching lines @@
 // TODO(sorin): consider making this a singleton.
 scoped_ptr<ComponentUpdateService> ComponentUpdateServiceFactory(
     const scoped_refptr<Configurator>& config) {
   DCHECK(config);
   auto update_client = update_client::UpdateClientFactory(config);
   return scoped_ptr<ComponentUpdateService>(
       new CrxUpdateService(config, std::move(update_client)));
 }
 
 }  // namespace component_updater