Componentize component_updater: Move some paths/constants to component.

chrome/browser/component_updater/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 "chrome/browser/component_updater/update_checker.h"
 
 #include "base/compiler_specific.h"
 #include "base/logging.h"
 #include "base/strings/stringprintf.h"
 #include "chrome/browser/component_updater/component_updater_utils.h"
@@ skipping 14 matching lines @@
 // the <request>.
 //
 // 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 std::vector<CrxUpdateItem*>& items,
+std::string BuildUpdateCheckRequest(const std::string& application_version,
+                                    const std::string& platform_name,
+                                    const std::vector<CrxUpdateItem*>& items,
                                     const std::string& additional_attributes) {
   std::string app_elements;
   for (size_t i = 0; i != items.size(); ++i) {
     const CrxUpdateItem* item = items[i];
     std::string app("<app ");
     base::StringAppendF(&app,
                         "appid=\"%s\" version=\"%s\"",
                         item->id.c_str(),
                         item->component.version.GetString().c_str());
     if (item->on_demand)
       base::StringAppendF(&app, " installsource=\"ondemand\"");
     base::StringAppendF(&app, ">");
     base::StringAppendF(&app, "<updatecheck />");
     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(app_elements, additional_attributes);
+  return BuildProtocolRequest(
+      application_version, platform_name, app_elements, additional_attributes);

[Sorin Jianu, 2014/06/19 00:48:22]

Same thing as for the ping manager.

 }
 
 class UpdateCheckerImpl : public UpdateChecker, public net::URLFetcherDelegate {
  public:
   UpdateCheckerImpl(const GURL& url,
                     net::URLRequestContextGetter* url_request_context_getter,
                     const UpdateCheckCallback& update_check_callback);
   virtual ~UpdateCheckerImpl();
 
   // Overrides for UpdateChecker.
   virtual bool CheckForUpdates(
+      const std::string& application_version,
+      const std::string& platform_name,
       const std::vector<CrxUpdateItem*>& items_to_check,
       const std::string& additional_attributes) OVERRIDE;
 
   // Overrides for UrlFetcher.
   virtual void OnURLFetchComplete(const net::URLFetcher* source) OVERRIDE;
 
  private:
   const GURL url_;
   net::URLRequestContextGetter* url_request_context_getter_;  // Not owned.
   const UpdateCheckCallback update_check_callback_;
@@ skipping 20 matching lines @@
       url_request_context_getter_(url_request_context_getter),
       update_check_callback_(update_check_callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 }
 
 UpdateCheckerImpl::~UpdateCheckerImpl() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 }
 
 bool UpdateCheckerImpl::CheckForUpdates(
+    const std::string& application_version,
+    const std::string& platform_name,
     const std::vector<CrxUpdateItem*>& items_to_check,
     const std::string& additional_attributes) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   if (url_fetcher_)
     return false;  // Another fetch is in progress.
 
-  url_fetcher_.reset(SendProtocolRequest(
-      url_,
-      BuildUpdateCheckRequest(items_to_check, additional_attributes),
-      this,
-      url_request_context_getter_));
+  url_fetcher_.reset(
+      SendProtocolRequest(url_,
+                          BuildUpdateCheckRequest(application_version,
+                                                  platform_name,
+                                                  items_to_check,
+                                                  additional_attributes),
+                          this,
+                          url_request_context_getter_));
 
   return true;
 }
 
 void UpdateCheckerImpl::OnURLFetchComplete(const net::URLFetcher* source) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(url_fetcher_.get() == source);
 
   int error = 0;
   std::string error_message;
@@ skipping 11 matching lines @@
     error = GetFetchError(*source);
     error_message.assign("network error");
     VLOG(1) << "Update request failed: network error";
   }
 
   url_fetcher_.reset();
   update_check_callback_.Run(error, error_message, update_response.results());
 }
 
 }  // namespace component_updater