Reland of Change the update_client task runner behavior to continue on shutdown.

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"
@@ skipping 53 matching lines @@
                void(const std::string& id,
                     const CrxDataCallback& crx_data_callback,
                     const CompletionCallback& completion_callback));
   MOCK_METHOD3(Update,
                void(const std::vector<std::string>& ids,
                     const CrxDataCallback& crx_data_callback,
                     const CompletionCallback& completion_callback));
   MOCK_CONST_METHOD2(GetCrxUpdateState,
                      bool(const std::string& id, CrxUpdateItem* update_item));
   MOCK_CONST_METHOD1(IsUpdating, bool(const std::string& id));
+  MOCK_METHOD0(Stop, void());
 
  private:
   ~MockUpdateClient() override;
 };
 
 class MockServiceObserver : public ServiceObserver {
  public:
   MockServiceObserver();
   ~MockServiceObserver() override;
 
@@ skipping 99 matching lines @@
 void ComponentUpdaterTest::TearDown() {
 }
 
 void ComponentUpdaterTest::RunThreads() {
   runloop_.Run();
 }
 
 TEST_F(ComponentUpdaterTest, AddObserver) {
   MockServiceObserver observer;
   EXPECT_CALL(update_client(), AddObserver(&observer)).Times(1);
+  EXPECT_CALL(update_client(), Stop()).Times(1);
   component_updater().AddObserver(&observer);
 }
 
 TEST_F(ComponentUpdaterTest, RemoveObserver) {
   MockServiceObserver observer;
   EXPECT_CALL(update_client(), RemoveObserver(&observer)).Times(1);
+  EXPECT_CALL(update_client(), Stop()).Times(1);
   component_updater().RemoveObserver(&observer);
 }
 
 // Tests that UpdateClient::Update is called by the timer loop when
 // components are registered, and the component update starts.
 // 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)
@@ skipping 34 matching lines @@
   crx_component2.pk_hash.assign(jebg_hash, jebg_hash + arraysize(jebg_hash));
   crx_component2.version = Version("0.9");
   crx_component2.installer = installer;
 
   // Quit after two update checks have fired.
   LoopHandler loop_handler(2, quit_closure());
   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));
 }
 
 // Tests that on-demand updates invoke UpdateClient::Install.
@@ skipping 31 matching lines @@
   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();
 }
 
 // Tests that throttling an update invokes UpdateClient::Install.
 TEST_F(ComponentUpdaterTest, MaybeThrottle) {
   class LoopHandler {
@@ skipping 24 matching lines @@
   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();
 }
 
 }  // namespace component_updater