Define a few simple UMA metrics for the component updater.

components/component_updater/component_updater_service_unittest.cc

 // Copyright 2015 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 <limits>
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
+#include "base/test/histogram_tester.h"
 #include "base/test/sequenced_worker_pool_owner.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/values.h"
 #include "components/component_updater/component_updater_service.h"
 #include "components/component_updater/component_updater_service_internal.h"
 #include "components/update_client/test_configurator.h"
 #include "components/update_client/test_installer.h"
 #include "components/update_client/update_client.h"
 
 #include "testing/gmock/include/gmock/gmock.h"
@@ skipping 180 matching lines @@
 // Also tests that Uninstall is called when a component is unregistered.
 TEST_F(ComponentUpdaterTest, RegisterComponent) {
   class LoopHandler {
    public:
     LoopHandler(int max_cnt, const base::Closure& quit_closure)
         : max_cnt_(max_cnt), quit_closure_(quit_closure) {}
 
     void OnUpdate(const std::vector<std::string>& ids,
                   const UpdateClient::CrxDataCallback& crx_data_callback,
                   const UpdateClient::CompletionCallback& completion_callback) {
+      completion_callback.Run(0);
       static int cnt = 0;
       ++cnt;
       if (cnt >= max_cnt_)
         quit_closure_.Run();
     }
 
    private:
     const int max_cnt_;
     base::Closure quit_closure_;
   };
 
+  base::HistogramTester ht;
+
   scoped_refptr<MockInstaller> installer(new MockInstaller());
   EXPECT_CALL(*installer, Uninstall()).WillOnce(Return(true));
 
   using update_client::jebg_hash;
   using update_client::abag_hash;
 
   const std::string id1 = "abagagagagagagagagagagagagagagag";
   const std::string id2 = "jebgalgnebhfojomionfpkfelancnnkf";
   std::vector<std::string> ids;
   ids.push_back(id1);
@@ skipping 14 matching lines @@
   EXPECT_CALL(update_client(), Update(ids, _, _))
       .WillRepeatedly(Invoke(&loop_handler, &LoopHandler::OnUpdate));
 
   EXPECT_CALL(update_client(), IsUpdating(id1)).Times(1);
   EXPECT_CALL(update_client(), Stop()).Times(1);
 
   EXPECT_TRUE(component_updater().RegisterComponent(crx_component1));
   EXPECT_TRUE(component_updater().RegisterComponent(crx_component2));
 
   RunThreads();
+  EXPECT_TRUE(component_updater().UnregisterComponent(id1));
 
-  EXPECT_TRUE(component_updater().UnregisterComponent(id1));
+  ht.ExpectUniqueSample("ComponentUpdater.Calls.Count", 1, 2);
+  ht.ExpectUniqueSample("ComponentUpdater.UpdateCompleteResult", 0, 2);
+  ht.ExpectTotalCount("ComponentUpdater.UpdateCompleteTime", 2);
 }
 
 // Tests that on-demand updates invoke UpdateClient::Install.
 TEST_F(ComponentUpdaterTest, OnDemandUpdate) {
   class LoopHandler {
    public:
     LoopHandler(int max_cnt, const base::Closure& quit_closure)
         : max_cnt_(max_cnt), quit_closure_(quit_closure) {}
 
     void OnInstall(
         const std::string& ids,
         const UpdateClient::CrxDataCallback& crx_data_callback,
         const UpdateClient::CompletionCallback& completion_callback) {
+      completion_callback.Run(0);
       static int cnt = 0;
       ++cnt;
       if (cnt >= max_cnt_)
         quit_closure_.Run();
     }
 
    private:
     const int max_cnt_;
     base::Closure quit_closure_;
   };
 
+  base::HistogramTester ht;
+
   auto config = configurator();
   config->SetInitialDelay(3600);
 
   auto& cus = component_updater();
 
   const std::string id = "jebgalgnebhfojomionfpkfelancnnkf";
   EXPECT_FALSE(OnDemandTester::OnDemand(&cus, id));
 
   scoped_refptr<MockInstaller> installer(new MockInstaller());
 
   using update_client::jebg_hash;
   CrxComponent crx_component;
   crx_component.pk_hash.assign(jebg_hash, jebg_hash + arraysize(jebg_hash));
   crx_component.version = Version("0.9");
   crx_component.installer = installer;
 
   LoopHandler loop_handler(1, quit_closure());
   EXPECT_CALL(update_client(),
               Install("jebgalgnebhfojomionfpkfelancnnkf", _, _))
       .WillOnce(Invoke(&loop_handler, &LoopHandler::OnInstall));
   EXPECT_CALL(update_client(), Stop()).Times(1);
 
   EXPECT_TRUE(cus.RegisterComponent(crx_component));
   EXPECT_TRUE(OnDemandTester::OnDemand(&cus, id));
 
   RunThreads();
+
+  ht.ExpectUniqueSample("ComponentUpdater.Calls.Count", 0, 1);
+  ht.ExpectUniqueSample("ComponentUpdater.UpdateCompleteResult", 0, 1);
+  ht.ExpectTotalCount("ComponentUpdater.UpdateCompleteTime", 1);
 }
 
 // Tests that throttling an update invokes UpdateClient::Install.
 TEST_F(ComponentUpdaterTest, MaybeThrottle) {
   class LoopHandler {
    public:
     LoopHandler(int max_cnt, const base::Closure& quit_closure)
         : max_cnt_(max_cnt), quit_closure_(quit_closure) {}
 
     void OnInstall(
         const std::string& ids,
         const UpdateClient::CrxDataCallback& crx_data_callback,
         const UpdateClient::CompletionCallback& completion_callback) {
+      completion_callback.Run(0);
       static int cnt = 0;
       ++cnt;
       if (cnt >= max_cnt_)
         quit_closure_.Run();
     }
 
    private:
     const int max_cnt_;
     base::Closure quit_closure_;
   };
 
+  base::HistogramTester ht;
+
   auto config = configurator();
   config->SetInitialDelay(3600);
 
   scoped_refptr<MockInstaller> installer(new MockInstaller());
 
   using update_client::jebg_hash;
   CrxComponent crx_component;
   crx_component.pk_hash.assign(jebg_hash, jebg_hash + arraysize(jebg_hash));
   crx_component.version = Version("0.9");
   crx_component.installer = installer;
 
   LoopHandler loop_handler(1, quit_closure());
   EXPECT_CALL(update_client(),
               Install("jebgalgnebhfojomionfpkfelancnnkf", _, _))
       .WillOnce(Invoke(&loop_handler, &LoopHandler::OnInstall));
   EXPECT_CALL(update_client(), Stop()).Times(1);
 
   EXPECT_TRUE(component_updater().RegisterComponent(crx_component));
   component_updater().MaybeThrottle(
       "jebgalgnebhfojomionfpkfelancnnkf",
       base::Bind(&ComponentUpdaterTest::ReadyCallback));
 
   RunThreads();
+
+  ht.ExpectUniqueSample("ComponentUpdater.Calls.Count", 0, 1);
+  ht.ExpectUniqueSample("ComponentUpdater.UpdateCompleteResult", 0, 1);
+  ht.ExpectTotalCount("ComponentUpdater.UpdateCompleteTime", 1);
 }
 
 }  // namespace component_updater