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

components/update_client/update_checker.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 <stddef.h>
 
 #include <memory>
 #include <string>
@@ skipping 127 matching lines @@
   // Include the updater state in the update check request.
   return BuildProtocolRequest(
       config.GetProdId(), config.GetBrowserVersion().GetString(),
       config.GetChannel(), config.GetLang(), config.GetOSLongName(),
       config.GetDownloadPreference(), app_elements, additional_attributes,
       updater_state_attributes);
 }
 
 class UpdateCheckerImpl : public UpdateChecker {
  public:
-  UpdateCheckerImpl(const scoped_refptr<Configurator>& config,
-                    PersistedData* metadata);
+  UpdateCheckerImpl(const scoped_refptr<Configurator>& config);
   ~UpdateCheckerImpl() override;
 
   // Overrides for UpdateChecker.
   bool CheckForUpdates(
       const std::vector<std::string>& ids_checked,
       const IdToComponentPtrMap& components,
       const std::string& additional_attributes,
       bool enabled_component_updates,
       const UpdateCheckCallback& update_check_callback) override;
 
  private:
   void ReadUpdaterStateAttributes();
   void CheckForUpdatesHelper(const IdToComponentPtrMap& components,
                              const std::string& additional_attributes,
                              bool enabled_component_updates);
   void OnRequestSenderComplete(const IdToComponentPtrMap& components,
                                int error,
                                const std::string& response,
                                int retry_after_sec);
   void UpdateCheckSucceeded(const IdToComponentPtrMap& components,
                             const UpdateResponse::Results& results,
                             int retry_after_sec);
   void UpdateCheckFailed(const IdToComponentPtrMap& components,
                          int error,
                          int retry_after_sec);
 
   base::ThreadChecker thread_checker_;
 
   const scoped_refptr<Configurator> config_;
-  PersistedData* metadata_ = nullptr;
+  std::unique_ptr<PersistedData> metadata_;
   std::vector<std::string> ids_checked_;
   UpdateCheckCallback update_check_callback_;
   std::unique_ptr<UpdaterState::Attributes> updater_state_attributes_;
   std::unique_ptr<RequestSender> request_sender_;
 
   DISALLOW_COPY_AND_ASSIGN(UpdateCheckerImpl);
 };
 
-UpdateCheckerImpl::UpdateCheckerImpl(const scoped_refptr<Configurator>& config,
-                                     PersistedData* metadata)
-    : config_(config), metadata_(metadata) {}
+UpdateCheckerImpl::UpdateCheckerImpl(const scoped_refptr<Configurator>& config)
+    : config_(config), metadata_(config->CreateMetadata()) {}

[waffles, 2017/05/12 17:33:34]

This will be called once per update check - I think this is OK, but it's
probably important to document that PersistedData itself can't have any state
that is supposed to live across updatechecks.

[Minh X. Nguyen, 2017/05/14 23:57:22]

As discussed offline, it's better to store PersistedData in UpdateEngine.

 
 UpdateCheckerImpl::~UpdateCheckerImpl() {
   DCHECK(thread_checker_.CalledOnValidThread());
 }
 
 bool UpdateCheckerImpl::CheckForUpdates(
     const std::vector<std::string>& ids_checked,
     const IdToComponentPtrMap& components,
     const std::string& additional_attributes,
     bool enabled_component_updates,
@@ skipping 24 matching lines @@
     bool enabled_component_updates) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   auto urls(config_->UpdateUrl());
   if (IsEncryptionRequired(components))
     RemoveUnsecureUrls(&urls);
 
   request_sender_ = base::MakeUnique<RequestSender>(config_);
   request_sender_->Send(
       config_->EnabledCupSigning(),
-      BuildUpdateCheckRequest(*config_, ids_checked_, components, metadata_,
-                              additional_attributes, enabled_component_updates,
+      BuildUpdateCheckRequest(*config_, ids_checked_, components,
+                              metadata_.get(), additional_attributes,
+                              enabled_component_updates,
                               updater_state_attributes_),
       urls,
       base::Bind(&UpdateCheckerImpl::OnRequestSenderComplete,
                  base::Unretained(this), base::ConstRef(components)));
 }
 
 void UpdateCheckerImpl::OnRequestSenderComplete(
     const IdToComponentPtrMap& components,
     int error,
     const std::string& response,
@@ skipping 60 matching lines @@
     component.set_update_check_error(error);
   }
 
   base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE, base::Bind(update_check_callback_, error, retry_after_sec));
 }
 
 }  // namespace
 
 std::unique_ptr<UpdateChecker> UpdateChecker::Create(
-    const scoped_refptr<Configurator>& config,
-    PersistedData* persistent) {
-  return base::MakeUnique<UpdateCheckerImpl>(config, persistent);
+    const scoped_refptr<Configurator>& config) {
+  return base::MakeUnique<UpdateCheckerImpl>(config);
 }
 
 }  // namespace update_client