Define EnabledComponentUpdates group policy 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 "components/component_updater/component_updater_service.h"
 
 #include <limits>
 #include <string>
 #include <vector>
 
@@ skipping 109 matching lines @@
 
   scoped_refptr<TestConfigurator> config_;
   scoped_refptr<MockUpdateClient> update_client_;
   std::unique_ptr<ComponentUpdateService> component_updater_;
 
   DISALLOW_COPY_AND_ASSIGN(ComponentUpdaterTest);
 };
 
 class OnDemandTester {
  public:
-  static bool OnDemand(ComponentUpdateService* cus, const std::string& id);
+  void OnDemand(ComponentUpdateService* cus, const std::string& id);
+  int error() const { return error_; }
+
+ private:
+  void OnDemandComplete(int error);
+
+  int error_ = 0;
 };
 
 MockInstaller::MockInstaller() {
 }
 
 MockInstaller::~MockInstaller() {
 }
 
 MockUpdateClient::MockUpdateClient() {
 }
 
 MockUpdateClient::~MockUpdateClient() {
 }
 
 MockServiceObserver::MockServiceObserver() {
 }
 
 MockServiceObserver::~MockServiceObserver() {
 }
 
-bool OnDemandTester::OnDemand(ComponentUpdateService* cus,
+void OnDemandTester::OnDemand(ComponentUpdateService* cus,
                               const std::string& id) {
-  return cus->GetOnDemandUpdater().OnDemandUpdate(id);
+  cus->GetOnDemandUpdater().OnDemandUpdate(
+      id,
+      base::Bind(&OnDemandTester::OnDemandComplete, base::Unretained(this)));
+}
+
+void OnDemandTester::OnDemandComplete(int error) {
+  error_ = error;
 }
 
 std::unique_ptr<ComponentUpdateService> TestComponentUpdateServiceFactory(
     const scoped_refptr<Configurator>& config) {
   DCHECK(config);
   return base::WrapUnique(new CrxUpdateService(config, new MockUpdateClient()));
 }
 
 ComponentUpdaterTest::ComponentUpdaterTest()
     : worker_pool_(
@@ skipping 103 matching lines @@
 
   ht.ExpectUniqueSample("ComponentUpdater.Calls", 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) {}
+    LoopHandler(int max_cnt) : max_cnt_(max_cnt) {}
 
     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();
+      if (cnt >= max_cnt_) {
+        base::ThreadTaskRunnerHandle::Get()->PostTask(
+            FROM_HERE, base::Bind(&LoopHandler::Quit, base::Unretained(this)));
+      }
     }
 
    private:
+    void Quit() { base::MessageLoop::current()->QuitWhenIdle(); }
+
     const int max_cnt_;
-    base::Closure quit_closure_;
   };
 
   base::HistogramTester ht;
 
   auto config = configurator();
   config->SetInitialDelay(3600);
 
   auto& cus = component_updater();
 
+  // Tests calling OnDemand for an unregistered component. This call results in
+  // an error, which is recorded by the OnDemandTester instance. Since the
+  // component was not registered, the call is ignored for UMA metrics.
+  OnDemandTester ondemand_tester_component_not_registered;
+  ondemand_tester_component_not_registered.OnDemand(
+      &cus, "ihfokbkgjpifnbbojhneepfflplebdkc");
+
   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;
+  crx_component.installer = new MockInstaller();
 
-  LoopHandler loop_handler(1, quit_closure());
+  LoopHandler loop_handler(1);
   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));
+  OnDemandTester ondemand_tester;
+  ondemand_tester.OnDemand(&cus, id);
 
-  RunThreads();
+  base::RunLoop().Run();
+
+  EXPECT_EQ(
+      static_cast<int>(update_client::Error::ERROR_UPDATE_INVALID_ARGUMENT),
+      ondemand_tester_component_not_registered.error());
+  EXPECT_EQ(0, ondemand_tester.error());
 
   ht.ExpectUniqueSample("ComponentUpdater.Calls", 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:
@@ skipping 41 matching lines @@
       base::Bind(&ComponentUpdaterTest::ReadyCallback));
 
   RunThreads();
 
   ht.ExpectUniqueSample("ComponentUpdater.Calls", 0, 1);
   ht.ExpectUniqueSample("ComponentUpdater.UpdateCompleteResult", 0, 1);
   ht.ExpectTotalCount("ComponentUpdater.UpdateCompleteTime", 1);
 }
 
 }  // namespace component_updater