Componentize component_updater: Move some paths/constants to component.

chrome/browser/component_updater/component_updater_service.cc

 // Copyright 2012 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/component_updater_service.h"
 
 #include <algorithm>
 #include <set>
 #include <vector>
 
@@ skipping 11 matching lines @@
 #include "base/threading/sequenced_worker_pool.h"
 #include "base/timer/timer.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/component_updater/component_unpacker.h"
 #include "chrome/browser/component_updater/component_updater_ping_manager.h"
 #include "chrome/browser/component_updater/component_updater_utils.h"
 #include "chrome/browser/component_updater/crx_downloader.h"
 #include "chrome/browser/component_updater/crx_update_item.h"
 #include "chrome/browser/component_updater/update_checker.h"
 #include "chrome/browser/component_updater/update_response.h"
-#include "chrome/common/chrome_version_info.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/resource_controller.h"
 #include "content/public/browser/resource_throttle.h"
 #include "url/gurl.h"
 
 using content::BrowserThread;
 
 namespace component_updater {
 
 // The component updater is designed to live until process shutdown, so
 // base::Bind() calls are not refcounted.
 
 namespace {
 
 // Returns true if the |proposed| version is newer than |current| version.
-bool IsVersionNewer(const Version& current, const std::string& proposed) {
-  Version proposed_ver(proposed);
+bool IsVersionNewer(const base::Version& current, const std::string& proposed) {
+  base::Version proposed_ver(proposed);
   return proposed_ver.IsValid() && current.CompareTo(proposed_ver) < 0;
 }
 
 // Returns true if a differential update is available, it has not failed yet,
 // and the configuration allows it.
 bool CanTryDiffUpdate(const CrxUpdateItem* update_item,
                       const ComponentUpdateService::Configurator& config) {
   return HasDiffUpdate(update_item) && !update_item->diff_update_failed &&
          config.DeltasEnabled();
 }
@@ skipping 78 matching lines @@
 // rest of the browser, so even if we have many components registered and
 // eligible for update, we only do one thing at a time with pauses in between
 // the tasks. Also when we do network requests there is only one |url_fetcher_|
 // in flight at a time.
 // There are no locks in this code, the main structure |work_items_| is mutated
 // only from the UI thread. The unpack and installation is done in a blocking
 // pool thread. The network requests are done in the IO thread or in the file
 // thread.
 class CrxUpdateService : public ComponentUpdateService, public OnDemandUpdater {
  public:
-  explicit CrxUpdateService(ComponentUpdateService::Configurator* config);
+  explicit CrxUpdateService(ComponentUpdateService::Configurator* config,
+                            const std::string& chrome_version,
+                            const std::string& platform_name);
   virtual ~CrxUpdateService();
 
   // Overrides for ComponentUpdateService.
   virtual void AddObserver(Observer* observer) OVERRIDE;
   virtual void RemoveObserver(Observer* observer) OVERRIDE;
   virtual Status Start() OVERRIDE;
   virtual Status Stop() OVERRIDE;
   virtual Status RegisterComponent(const CrxComponent& component) OVERRIDE;
   virtual std::vector<std::string> GetComponentIDs() const OVERRIDE;
   virtual CrxUpdateItem* GetComponentDetails(
@@ skipping 97 matching lines @@
   scoped_ptr<CrxDownloader> crx_downloader_;
 
   // A collection of every work item.
   typedef std::vector<CrxUpdateItem*> UpdateItems;
   UpdateItems work_items_;
 
   base::OneShotTimer<CrxUpdateService> timer_;
 
   scoped_refptr<base::SequencedTaskRunner> blocking_task_runner_;
 
-  const Version chrome_version_;
+  const base::Version chrome_version_;
+  const std::string platform_name_;
 
   bool running_;
 
   ObserverList<Observer> observer_list_;
 
   DISALLOW_COPY_AND_ASSIGN(CrxUpdateService);
 };
 
 //////////////////////////////////////////////////////////////////////////////
 
-CrxUpdateService::CrxUpdateService(ComponentUpdateService::Configurator* config)
+CrxUpdateService::CrxUpdateService(ComponentUpdateService::Configurator* config,
+                                   const std::string& chrome_version,
+                                   const std::string& platform_name)
     : config_(config),
       ping_manager_(
-          new PingManager(config->PingUrl(), config->RequestContext())),
+          new PingManager(chrome_version, platform_name, config->PingUrl(),
+                          config->RequestContext())),
       blocking_task_runner_(
           BrowserThread::GetBlockingPool()->
               GetSequencedTaskRunnerWithShutdownBehavior(
                   BrowserThread::GetBlockingPool()->GetSequenceToken(),
                   base::SequencedWorkerPool::SKIP_ON_SHUTDOWN)),
-      chrome_version_(chrome::VersionInfo().Version()),
+      chrome_version_(chrome_version),
+      platform_name_(platform_name),
       running_(false) {
 }
 
 CrxUpdateService::~CrxUpdateService() {
   // Because we are a singleton, at this point only the UI thread should be
   // alive, this simplifies the management of the work that could be in
   // flight in other threads.
   Stop();
   STLDeleteElements(&work_items_);
 }
@@ skipping 303 matching lines @@
     VLOG(1) << "Scheduling update check for component id=" << item->id
             << ", time_since_last_checked="
             << time_since_last_checked.InSeconds() << " seconds";
 
     ChangeItemState(item, CrxUpdateItem::kChecking);
 
     item->last_check = now;
     item->crx_urls.clear();
     item->crx_diffurls.clear();
     item->previous_version = item->component.version;
-    item->next_version = Version();
+    item->next_version = base::Version();
     item->previous_fp = item->component.fingerprint;
     item->next_fp.clear();
     item->diff_update_failed = false;
     item->error_category = 0;
     item->error_code = 0;
     item->extra_code1 = 0;
     item->diff_error_category = 0;
     item->diff_error_code = 0;
     item->diff_extra_code1 = 0;
     item->download_metrics.clear();
 
     items_to_check.push_back(item);
   }
 
   if (items_to_check.empty())
     return false;
 
   update_checker_ =
       UpdateChecker::Create(config_->UpdateUrl(),
                             config_->RequestContext(),
                             base::Bind(&CrxUpdateService::UpdateCheckComplete,
                                        base::Unretained(this))).Pass();
-  return update_checker_->CheckForUpdates(items_to_check,
+  return update_checker_->CheckForUpdates(chrome_version_.GetString(),
+                                          platform_name_, items_to_check,
                                           config_->ExtraRequestParams());
 }
 
 void CrxUpdateService::UpdateComponent(CrxUpdateItem* workitem) {
   scoped_ptr<CRXContext> crx_context(new CRXContext);
   crx_context->pk_hash = workitem->component.pk_hash;
   crx_context->id = workitem->id;
   crx_context->installer = workitem->component.installer;
   crx_context->fingerprint = workitem->next_fp;
   const std::vector<GURL>* urls = NULL;
@@ skipping 84 matching lines @@
     }
 
     if (it->manifest.packages.size() != 1) {
       // Assume one and only one package per component.
       VLOG(1) << "Ignoring multiple packages for component: " << crx->id;
       ChangeItemState(crx, CrxUpdateItem::kNoUpdate);
       continue;
     }
 
     // Parse the members of the result and queue an upgrade for this component.
-    crx->next_version = Version(it->manifest.version);
+    crx->next_version = base::Version(it->manifest.version);
 
     VLOG(1) << "Update found for component: " << crx->id;
 
     typedef UpdateResponse::Result::Manifest::Package Package;
     const Package& package(it->manifest.packages[0]);
     crx->next_fp = package.fingerprint;
 
     // Resolve the urls by combining the base urls with the package names.
     for (size_t i = 0; i != it->crx_urls.size(); ++i) {
       const GURL url(it->crx_urls[i].Resolve(package.name));
@@ skipping 331 matching lines @@
 void CUResourceThrottle::Unblock() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   if (state_ == BLOCKED)
     controller()->Resume();
   state_ = UNBLOCKED;
 }
 
 // The component update factory. Using the component updater as a singleton
 // is the job of the browser process.
 ComponentUpdateService* ComponentUpdateServiceFactory(
-    ComponentUpdateService::Configurator* config) {
+    ComponentUpdateService::Configurator* config,
+    const std::string& chrome_version,
+    const std::string& platform_name) {
   DCHECK(config);
-  return new CrxUpdateService(config);
+  return new CrxUpdateService(config, chrome_version, platform_name);
 }
 
 }  // namespace component_updater