Implement ping_freshness for update_client.

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 <string>
 #include <vector>
@@ skipping 46 matching lines @@
 // An app element looks like this:
 //    <app appid="hnimpnehoodheedghdeeijklkeaacbdc"
 //         version="0.1.2.3" installsource="ondemand">
 //      <updatecheck />
 //      <packages>
 //        <package fp="abcd" />
 //      </packages>
 //    </app>
 std::string BuildUpdateCheckRequest(const Configurator& config,
                                     const std::vector<CrxUpdateItem*>& items,
-                                    const PersistedData& metadata,
+                                    PersistedData* metadata,
                                     const std::string& additional_attributes) {
   const std::string brand(SanitizeBrand(config.GetBrand()));
   std::string app_elements;
   for (size_t i = 0; i != items.size(); ++i) {
     const CrxUpdateItem* item = items[i];
     const std::string ap(SanitizeAp(item->component.ap));
     std::string app("<app ");
     base::StringAppendF(&app, "appid=\"%s\" version=\"%s\"", item->id.c_str(),
                         item->component.version.GetString().c_str());
     if (!brand.empty())
       base::StringAppendF(&app, " brand=\"%s\"", brand.c_str());
     if (item->on_demand)
       base::StringAppendF(&app, " installsource=\"ondemand\"");
     if (!ap.empty())
       base::StringAppendF(&app, " ap=\"%s\"", ap.c_str());
     base::StringAppendF(&app, ">");
     base::StringAppendF(&app, "<updatecheck />");
-    base::StringAppendF(&app, "<ping rd=\"%d\" />",
-                        metadata.GetDateLastRollCall(item->id));
+    base::StringAppendF(&app, "<ping rd=\"%d\" ping_freshness=\"%s\" />",
+                        metadata->GetDateLastRollCall(item->id),
+                        metadata->GetPingFreshness(item->id).c_str());
     if (!item->component.fingerprint.empty()) {
       base::StringAppendF(&app,
                           "<packages>"
                           "<package fp=\"%s\"/>"
                           "</packages>",
                           item->component.fingerprint.c_str());
     }
     base::StringAppendF(&app, "</app>");
     app_elements.append(app);
     VLOG(1) << "Appending to update request: " << app;
   }
 
   return BuildProtocolRequest(
       config.GetBrowserVersion().GetString(), config.GetChannel(),
       config.GetLang(), config.GetOSLongName(), config.GetDownloadPreference(),
       app_elements, additional_attributes);
 }
 
 class UpdateCheckerImpl : public UpdateChecker {
  public:
   UpdateCheckerImpl(const scoped_refptr<Configurator>& config,
-                    const PersistedData& metadata);
+                    PersistedData* metadata);
   ~UpdateCheckerImpl() override;
 
   // Overrides for UpdateChecker.
   bool CheckForUpdates(
       const std::vector<CrxUpdateItem*>& items_to_check,
       const std::string& additional_attributes,
       const UpdateCheckCallback& update_check_callback) override;
 
  private:
   void OnRequestSenderComplete(scoped_ptr<std::vector<std::string>> ids_checked,
                                int error,
                                const std::string& response,
                                int retry_after_sec);
   base::ThreadChecker thread_checker_;
 
   const scoped_refptr<Configurator> config_;
-  const PersistedData& metadata_;
+  PersistedData* metadata_;
   UpdateCheckCallback update_check_callback_;
   scoped_ptr<RequestSender> request_sender_;
 
   DISALLOW_COPY_AND_ASSIGN(UpdateCheckerImpl);
 };
 
 UpdateCheckerImpl::UpdateCheckerImpl(const scoped_refptr<Configurator>& config,
-                                     const PersistedData& metadata)
+                                     PersistedData* metadata)
     : config_(config), metadata_(metadata) {}
 
 UpdateCheckerImpl::~UpdateCheckerImpl() {
   DCHECK(thread_checker_.CalledOnValidThread());
 }
 
 bool UpdateCheckerImpl::CheckForUpdates(
     const std::vector<CrxUpdateItem*>& items_to_check,
     const std::string& additional_attributes,
     const UpdateCheckCallback& update_check_callback) {
@@ skipping 29 matching lines @@
     int error,
     const std::string& response,
     int retry_after_sec) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   if (!error) {
     UpdateResponse update_response;
     if (update_response.Parse(response)) {
       int daynum = update_response.results().daystart_elapsed_days;
       if (daynum != UpdateResponse::kNoDaystart)
-        metadata_.SetDateLastRollCall(*ids_checked, daynum);
+        metadata_->SetDateLastRollCall(*ids_checked, daynum);
       base::ThreadTaskRunnerHandle::Get()->PostTask(
           FROM_HERE, base::Bind(update_check_callback_, error,
                                 update_response.results(), retry_after_sec));
       return;
     }
 
     error = -1;
     VLOG(1) << "Parse failed " << update_response.errors();
   }
 
   base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE, base::Bind(update_check_callback_, error,
                             UpdateResponse::Results(), retry_after_sec));
 }
 
 }  // namespace
 
 scoped_ptr<UpdateChecker> UpdateChecker::Create(
     const scoped_refptr<Configurator>& config,
-    const PersistedData& persistent) {
+    PersistedData* persistent) {
   return scoped_ptr<UpdateChecker>(new UpdateCheckerImpl(config, persistent));
 }
 
 }  // namespace update_client