Prepare to abstract PersistedData by making it part of the configurator.

components/update_client/update_checker_unittest.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/update_client/update_checker.h"
 
 #include <memory>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 51 matching lines @@
 
  protected:
   void Quit();
   void RunThreads();
   void RunThreadsUntilIdle();
 
   std::unique_ptr<Component> MakeComponent() const;
 
   scoped_refptr<TestConfigurator> config_;
   std::unique_ptr<TestingPrefServiceSimple> pref_;
-  std::unique_ptr<PersistedData> metadata_;
 
   std::unique_ptr<UpdateChecker> update_checker_;
 
   std::unique_ptr<InterceptorFactory> interceptor_factory_;
   URLRequestPostInterceptor* post_interceptor_ =
       nullptr;  // Owned by the factory.
 
   int error_ = 0;
   int retry_after_sec_ = 0;
 
   std::unique_ptr<UpdateContext> update_context_;
 
  private:
   std::unique_ptr<UpdateContext> MakeFakeUpdateContext() const;
 
   base::MessageLoopForIO loop_;
   base::test::ScopedTaskScheduler scoped_task_scheduler_;
   base::Closure quit_closure_;
 
   DISALLOW_COPY_AND_ASSIGN(UpdateCheckerTest);
 };
 
 UpdateCheckerTest::UpdateCheckerTest() : scoped_task_scheduler_(&loop_) {}
 
 UpdateCheckerTest::~UpdateCheckerTest() {
 }
 
 void UpdateCheckerTest::SetUp() {
+  pref_ = base::MakeUnique<TestingPrefServiceSimple>();
   config_ = base::MakeShared<TestConfigurator>(
       base::ThreadTaskRunnerHandle::Get(), base::ThreadTaskRunnerHandle::Get());
-  pref_ = base::MakeUnique<TestingPrefServiceSimple>();
+  config_->SetPrefService(pref_.get());
   PersistedData::RegisterPrefs(pref_->registry());
-  metadata_ = base::MakeUnique<PersistedData>(pref_.get());
   interceptor_factory_ =
       base::MakeUnique<InterceptorFactory>(base::ThreadTaskRunnerHandle::Get());
   post_interceptor_ = interceptor_factory_->CreateInterceptor();
   EXPECT_TRUE(post_interceptor_);
 
   update_checker_ = nullptr;
 
   error_ = 0;
   retry_after_sec_ = 0;
   update_context_ = MakeFakeUpdateContext();
@@ skipping 59 matching lines @@
   component->state_ = base::MakeUnique<Component::StateNew>(component.get());
   component->crx_component_ = crx_component;
 
   return component;
 }
 
 TEST_F(UpdateCheckerTest, UpdateCheckSuccess) {
   EXPECT_TRUE(post_interceptor_->ExpectRequest(
       new PartialMatch("updatecheck"), test_file("updatecheck_reply_1.xml")));
 
-  update_checker_ = UpdateChecker::Create(config_, metadata_.get());
+  update_checker_ = UpdateChecker::Create(config_);
 
   IdToComponentPtrMap components;
   components[kUpdateItemId] = MakeComponent();
 
   auto& component = components[kUpdateItemId];
   component->crx_component_.installer_attributes["ap"] = "some_ap";
 
   update_checker_->CheckForUpdates(
       std::vector<std::string>{kUpdateItemId}, components, "extra=\"params\"",
       true,
@@ skipping 47 matching lines @@
   EXPECT_NE(string::npos, request.find(" name=\"Omaha\" "));
 #endif  // GOOGLE_CHROME_BUILD
 #endif  // OS_WINDOWS
 }
 
 // Tests that an invalid "ap" is not serialized.
 TEST_F(UpdateCheckerTest, UpdateCheckInvalidAp) {
   EXPECT_TRUE(post_interceptor_->ExpectRequest(
       new PartialMatch("updatecheck"), test_file("updatecheck_reply_1.xml")));
 
-  update_checker_ = UpdateChecker::Create(config_, metadata_.get());
+  update_checker_ = UpdateChecker::Create(config_);
 
   IdToComponentPtrMap components;
   components[kUpdateItemId] = MakeComponent();
 
   // Make "ap" too long.
   auto& component = components[kUpdateItemId];
   component->crx_component_.installer_attributes["ap"] = std::string(257, 'a');
 
   update_checker_->CheckForUpdates(
       std::vector<std::string>{kUpdateItemId}, components, "", true,
       base::Bind(&UpdateCheckerTest::UpdateCheckComplete,
                  base::Unretained(this)));
 
   RunThreads();
 
   EXPECT_NE(string::npos, post_interceptor_->GetRequests()[0].find(
                               std::string("app appid=\"") + kUpdateItemId +
                               "\" version=\"0.9\" "
                               "brand=\"TEST\"><updatecheck/><ping rd=\"-2\" "));
   EXPECT_NE(string::npos,
             post_interceptor_->GetRequests()[0].find(
                 "<packages><package fp=\"fp1\"/></packages></app>"));
 }
 
 TEST_F(UpdateCheckerTest, UpdateCheckSuccessNoBrand) {
   EXPECT_TRUE(post_interceptor_->ExpectRequest(
       new PartialMatch("updatecheck"), test_file("updatecheck_reply_1.xml")));
 
   config_->SetBrand("TOOLONG");   // Sets an invalid brand code.
-  update_checker_ = UpdateChecker::Create(config_, metadata_.get());
+  update_checker_ = UpdateChecker::Create(config_);
 
   IdToComponentPtrMap components;
   components[kUpdateItemId] = MakeComponent();
 
   update_checker_->CheckForUpdates(
       std::vector<std::string>{kUpdateItemId}, components, "", true,
       base::Bind(&UpdateCheckerTest::UpdateCheckComplete,
                  base::Unretained(this)));
 
   RunThreads();
 
   EXPECT_NE(string::npos, post_interceptor_->GetRequests()[0].find(
                               std::string("<app appid=\"") + kUpdateItemId +
                               "\" version=\"0.9\">"
                               "<updatecheck/><ping rd=\"-2\" "));
   EXPECT_NE(string::npos,
             post_interceptor_->GetRequests()[0].find(
                 "<packages><package fp=\"fp1\"/></packages></app>"));
 }
 
 // Simulates a 403 server response error.
 TEST_F(UpdateCheckerTest, UpdateCheckError) {
   EXPECT_TRUE(
       post_interceptor_->ExpectRequest(new PartialMatch("updatecheck"), 403));
 
-  update_checker_ = UpdateChecker::Create(config_, metadata_.get());
+  update_checker_ = UpdateChecker::Create(config_);
 
   IdToComponentPtrMap components;
   components[kUpdateItemId] = MakeComponent();
 
   auto& component = components[kUpdateItemId];
 
   update_checker_->CheckForUpdates(
       std::vector<std::string>{kUpdateItemId}, components, "", true,
       base::Bind(&UpdateCheckerTest::UpdateCheckComplete,
                  base::Unretained(this)));
   RunThreads();
 
   EXPECT_EQ(1, post_interceptor_->GetHitCount())
       << post_interceptor_->GetRequestsAsString();
   EXPECT_EQ(1, post_interceptor_->GetCount())
       << post_interceptor_->GetRequestsAsString();
 
   EXPECT_EQ(403, error_);
   EXPECT_FALSE(component->next_version_.IsValid());
 }
 
 TEST_F(UpdateCheckerTest, UpdateCheckDownloadPreference) {
   EXPECT_TRUE(post_interceptor_->ExpectRequest(
       new PartialMatch("updatecheck"), test_file("updatecheck_reply_1.xml")));
 
   config_->SetDownloadPreference(string("cacheable"));
 
-  update_checker_ = UpdateChecker::Create(config_, metadata_.get());
+  update_checker_ = UpdateChecker::Create(config_);
 
   IdToComponentPtrMap components;
   components[kUpdateItemId] = MakeComponent();
 
   update_checker_->CheckForUpdates(
       std::vector<std::string>{kUpdateItemId}, components, "extra=\"params\"",
       true,
       base::Bind(&UpdateCheckerTest::UpdateCheckComplete,
                  base::Unretained(this)));
 
   RunThreads();
 
   // The request must contain dlpref="cacheable".
   EXPECT_NE(string::npos,
             post_interceptor_->GetRequests()[0].find(" dlpref=\"cacheable\""));
 }
 
 // This test is checking that an update check signed with CUP fails, since there
 // is currently no entity that can respond with a valid signed response.
 // A proper CUP test requires network mocks, which are not available now.
 TEST_F(UpdateCheckerTest, UpdateCheckCupError) {
   EXPECT_TRUE(post_interceptor_->ExpectRequest(
       new PartialMatch("updatecheck"), test_file("updatecheck_reply_1.xml")));
 
   config_->SetEnabledCupSigning(true);
-  update_checker_ = UpdateChecker::Create(config_, metadata_.get());
+  update_checker_ = UpdateChecker::Create(config_);
 
   IdToComponentPtrMap components;
   components[kUpdateItemId] = MakeComponent();
 
   const auto& component = components[kUpdateItemId];
 
   update_checker_->CheckForUpdates(
       std::vector<std::string>{kUpdateItemId}, components, "", true,
       base::Bind(&UpdateCheckerTest::UpdateCheckComplete,
                  base::Unretained(this)));
@@ skipping 17 matching lines @@
   // Expect an error since the response is not trusted.
   EXPECT_EQ(-10000, error_);
   EXPECT_FALSE(component->next_version_.IsValid());
 }
 
 // Tests that the UpdateCheckers will not make an update check for a
 // component that requires encryption when the update check URL is unsecure.
 TEST_F(UpdateCheckerTest, UpdateCheckRequiresEncryptionError) {
   config_->SetUpdateCheckUrl(GURL("http:\\foo\bar"));
 
-  update_checker_ = UpdateChecker::Create(config_, metadata_.get());
+  update_checker_ = UpdateChecker::Create(config_);
 
   IdToComponentPtrMap components;
   components[kUpdateItemId] = MakeComponent();
 
   auto& component = components[kUpdateItemId];
   component->crx_component_.requires_network_encryption = true;
 
   update_checker_->CheckForUpdates(
       std::vector<std::string>{kUpdateItemId}, components, "", true,
       base::Bind(&UpdateCheckerTest::UpdateCheckComplete,
                  base::Unretained(this)));
   RunThreads();
 
   EXPECT_EQ(-1, error_);
   EXPECT_FALSE(component->next_version_.IsValid());
 }
 
 // Tests that the PersistedData will get correctly update and reserialize
 // the elapsed_days value.
 TEST_F(UpdateCheckerTest, UpdateCheckDateLastRollCall) {
   EXPECT_TRUE(post_interceptor_->ExpectRequest(
       new PartialMatch("updatecheck"), test_file("updatecheck_reply_4.xml")));
   EXPECT_TRUE(post_interceptor_->ExpectRequest(
       new PartialMatch("updatecheck"), test_file("updatecheck_reply_4.xml")));
 
-  update_checker_ = UpdateChecker::Create(config_, metadata_.get());
+  update_checker_ = UpdateChecker::Create(config_);
 
   IdToComponentPtrMap components;
   components[kUpdateItemId] = MakeComponent();
 
   // Do two update-checks.
   update_checker_->CheckForUpdates(
       std::vector<std::string>{kUpdateItemId}, components, "extra=\"params\"",
       true,
       base::Bind(&UpdateCheckerTest::UpdateCheckComplete,
                  base::Unretained(this)));
   RunThreads();
 
-  update_checker_ = UpdateChecker::Create(config_, metadata_.get());
+  update_checker_ = UpdateChecker::Create(config_);
   update_checker_->CheckForUpdates(
       std::vector<std::string>{kUpdateItemId}, components, "extra=\"params\"",
       true,
       base::Bind(&UpdateCheckerTest::UpdateCheckComplete,
                  base::Unretained(this)));
   RunThreads();
 
   EXPECT_EQ(2, post_interceptor_->GetHitCount())
       << post_interceptor_->GetRequestsAsString();
   ASSERT_EQ(2, post_interceptor_->GetCount())
       << post_interceptor_->GetRequestsAsString();
   EXPECT_NE(string::npos, post_interceptor_->GetRequests()[0].find(
                               "<ping rd=\"-2\" ping_freshness="));
   EXPECT_NE(string::npos, post_interceptor_->GetRequests()[1].find(
                               "<ping rd=\"3383\" ping_freshness="));
 }
 
 TEST_F(UpdateCheckerTest, UpdateCheckUpdateDisabled) {
   EXPECT_TRUE(post_interceptor_->ExpectRequest(
       new PartialMatch("updatecheck"), test_file("updatecheck_reply_1.xml")));
 
   config_->SetBrand("");
-  update_checker_ = UpdateChecker::Create(config_, metadata_.get());
+  update_checker_ = UpdateChecker::Create(config_);
 
   IdToComponentPtrMap components;
   components[kUpdateItemId] = MakeComponent();
 
   auto& component = components[kUpdateItemId];
 
   // Tests the scenario where:
   //  * the component does not support group policies.
   //  * the component updates are disabled.
   // Expects the group policy to be ignored and the update check to not
@@ skipping 10 matching lines @@
                               std::string("<app appid=\"") + kUpdateItemId +
                               "\" version=\"0.9\">"
                               "<updatecheck/>"));
 
   // Tests the scenario where:
   //  * the component supports group policies.
   //  * the component updates are disabled.
   // Expects the update check to include the "updatedisabled" attribute.
   component->crx_component_.supports_group_policy_enable_component_updates =
       true;
-  update_checker_ = UpdateChecker::Create(config_, metadata_.get());
+  update_checker_ = UpdateChecker::Create(config_);
   update_checker_->CheckForUpdates(
       std::vector<std::string>{kUpdateItemId}, components, "", false,
       base::Bind(&UpdateCheckerTest::UpdateCheckComplete,
                  base::Unretained(this)));
   RunThreads();
   EXPECT_NE(string::npos, post_interceptor_->GetRequests()[1].find(
                               std::string("<app appid=\"") + kUpdateItemId +
                               "\" version=\"0.9\">"
                               "<updatecheck updatedisabled=\"true\"/>"));
 
   // Tests the scenario where:
   //  * the component does not support group policies.
   //  * the component updates are enabled.
   // Expects the update check to not include the "updatedisabled" attribute.
   component->crx_component_.supports_group_policy_enable_component_updates =
       false;
-  update_checker_ = UpdateChecker::Create(config_, metadata_.get());
+  update_checker_ = UpdateChecker::Create(config_);
   update_checker_->CheckForUpdates(
       std::vector<std::string>{kUpdateItemId}, components, "", true,
       base::Bind(&UpdateCheckerTest::UpdateCheckComplete,
                  base::Unretained(this)));
   RunThreads();
   EXPECT_NE(string::npos, post_interceptor_->GetRequests()[2].find(
                               std::string("<app appid=\"") + kUpdateItemId +
                               "\" version=\"0.9\">"
                               "<updatecheck/>"));
 
   // Tests the scenario where:
   //  * the component supports group policies.
   //  * the component updates are enabled.
   // Expects the update check to not include the "updatedisabled" attribute.
   component->crx_component_.supports_group_policy_enable_component_updates =
       true;
-  update_checker_ = UpdateChecker::Create(config_, metadata_.get());
+  update_checker_ = UpdateChecker::Create(config_);
   update_checker_->CheckForUpdates(
       std::vector<std::string>{kUpdateItemId}, components, "", true,
       base::Bind(&UpdateCheckerTest::UpdateCheckComplete,
                  base::Unretained(this)));
   RunThreads();
   EXPECT_NE(string::npos, post_interceptor_->GetRequests()[3].find(
                               std::string("<app appid=\"") + kUpdateItemId +
                               "\" version=\"0.9\">"
                               "<updatecheck/>"));
 }
 
 TEST_F(UpdateCheckerTest, NoUpdateActionRun) {
   EXPECT_TRUE(post_interceptor_->ExpectRequest(
       new PartialMatch("updatecheck"),
       test_file("updatecheck_reply_noupdate.xml")));
 
-  update_checker_ = UpdateChecker::Create(config_, metadata_.get());
+  update_checker_ = UpdateChecker::Create(config_);
 
   IdToComponentPtrMap components;
   components[kUpdateItemId] = MakeComponent();
 
   auto& component = components[kUpdateItemId];
 
   update_checker_->CheckForUpdates(
       std::vector<std::string>{kUpdateItemId}, components, "", true,
       base::Bind(&UpdateCheckerTest::UpdateCheckComplete,
                  base::Unretained(this)));
   RunThreads();
 
   EXPECT_EQ(1, post_interceptor_->GetHitCount())
       << post_interceptor_->GetRequestsAsString();
   ASSERT_EQ(1, post_interceptor_->GetCount())
       << post_interceptor_->GetRequestsAsString();
 
   EXPECT_EQ(0, error_);
   EXPECT_STREQ("this", component->action_run_.c_str());
 }
 
 }  // namespace update_client