Move component updater artifacts into component_updater namespace.

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 18 matching lines @@
 #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;
 
-using component_updater::CrxDownloader;
-using component_updater::CrxUpdateItem;
+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);
   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 component_updater::HasDiffUpdate(update_item) &&
+  return HasDiffUpdate(update_item) &&
          !update_item->diff_update_failed &&
          config.DeltasEnabled();
 }
 
 void AppendDownloadMetrics(
     const std::vector<CrxDownloader::DownloadMetrics>& source,
     std::vector<CrxDownloader::DownloadMetrics>* destination) {
   destination->insert(destination->end(), source.begin(), source.end());
 }
 
@@ skipping 120 matching lines @@
     kUnpackError,
     kInstallError,
   };
 
   enum StepDelayInterval {
     kStepDelayShort = 0,
     kStepDelayMedium,
     kStepDelayLong,
   };
 
-  void UpdateCheckComplete(
-      int error,
-      const std::string& error_message,
-      const component_updater::UpdateResponse::Results& results);
-  void OnUpdateCheckSucceeded(
-      const component_updater::UpdateResponse::Results& results);
+  void UpdateCheckComplete(int error,
+                           const std::string& error_message,
+                           const UpdateResponse::Results& results);
+  void OnUpdateCheckSucceeded(const UpdateResponse::Results& results);
   void OnUpdateCheckFailed(int error, const std::string& error_message);
 
   void DownloadComplete(
       scoped_ptr<CRXContext> crx_context,
       const CrxDownloader::Result& download_result);
 
   Status OnDemandUpdateInternal(CrxUpdateItem* item);
 
   void ProcessPendingItems();
 
@@ skipping 29 matching lines @@
 
   bool HasOnDemandItems() const;
 
   void OnNewResourceThrottle(base::WeakPtr<CUResourceThrottle> rt,
                              const std::string& crx_id);
 
   scoped_ptr<ComponentUpdateService::Configurator> config_;
 
   scoped_ptr<ComponentPatcher> component_patcher_;
 
-  scoped_ptr<component_updater::UpdateChecker> update_checker_;
+  scoped_ptr<UpdateChecker> update_checker_;
 
-  scoped_ptr<component_updater::PingManager> ping_manager_;
+  scoped_ptr<PingManager> ping_manager_;
 
-  scoped_ptr<component_updater::CrxDownloader> crx_downloader_;
+  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_;
 
   bool running_;
 
   DISALLOW_COPY_AND_ASSIGN(CrxUpdateService);
 };
 
 //////////////////////////////////////////////////////////////////////////////
 
 CrxUpdateService::CrxUpdateService(ComponentUpdateService::Configurator* config)
     : config_(config),
       component_patcher_(config->CreateComponentPatcher()),
-      ping_manager_(new component_updater::PingManager(
-          config->PingUrl(),
-          config->RequestContext())),
+      ping_manager_(new PingManager(config->PingUrl(),
+                                    config->RequestContext())),
       blocking_task_runner_(BrowserThread::GetBlockingPool()->
           GetSequencedTaskRunnerWithShutdownBehavior(
               BrowserThread::GetBlockingPool()->GetSequenceToken(),
               base::SequencedWorkerPool::SKIP_ON_SHUTDOWN)),
       chrome_version_(chrome::VersionInfo().Version()),
       running_(false) {
 }
 
 CrxUpdateService::~CrxUpdateService() {
   // Because we are a singleton, at this point only the UI thread should be
@@ skipping 167 matching lines @@
 // Adds a component to be checked for upgrades. If the component exists it
 // it will be replaced and the return code is kReplaced.
 ComponentUpdateService::Status CrxUpdateService::RegisterComponent(
     const CrxComponent& component) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   if (component.pk_hash.empty() ||
       !component.version.IsValid() ||
       !component.installer)
     return kError;
 
-  std::string id(component_updater::GetCrxComponentID(component));
+  std::string id(GetCrxComponentID(component));
   CrxUpdateItem* uit = FindUpdateItemById(id);
   if (uit) {
     uit->component = component;
     return kReplaced;
   }
 
   uit = new CrxUpdateItem;
   uit->id.swap(id);
   uit->component = component;
 
@@ skipping 58 matching lines @@
   return kOk;
 }
 
 void CrxUpdateService::GetComponents(
     std::vector<CrxComponentInfo>* components) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   for (UpdateItems::const_iterator it = work_items_.begin();
        it != work_items_.end(); ++it) {
     const CrxUpdateItem* item = *it;
     CrxComponentInfo info;
-    info.id = component_updater::GetCrxComponentID(item->component);
+    info.id = GetCrxComponentID(item->component);
     info.version = item->component.version.GetString();
     info.name = item->component.name;
     components->push_back(info);
   }
 }
 
 // This is the main loop of the component updater. It updates one component
 // at a time if updates are available. Otherwise, it does an update check or
 // takes a long sleep until the loop runs again.
 void CrxUpdateService::ProcessPendingItems() {
@@ skipping 60 matching lines @@
     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_ = component_updater::UpdateChecker::Create(
+  update_checker_ = UpdateChecker::Create(
       config_->UpdateUrl(),
       config_->RequestContext(),
       base::Bind(&CrxUpdateService::UpdateCheckComplete,
                  base::Unretained(this))).Pass();
   return update_checker_->CheckForUpdates(items_to_check,
                                           config_->ExtraRequestParams());
 }
 
 void CrxUpdateService::UpdateComponent(CrxUpdateItem* workitem) {
   scoped_ptr<CRXContext> crx_context(new CRXContext);
@@ skipping 20 matching lines @@
       blocking_task_runner_,
       base::Bind(&CrxUpdateService::DownloadComplete,
                  base::Unretained(this),
                  base::Passed(&crx_context))));
   crx_downloader_->StartDownload(*urls);
 }
 
 void CrxUpdateService::UpdateCheckComplete(
     int error,
     const std::string& error_message,
-    const component_updater::UpdateResponse::Results& results) {
+    const UpdateResponse::Results& results) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   update_checker_.reset();
   if (!error)
     OnUpdateCheckSucceeded(results);
   else
     OnUpdateCheckFailed(error, error_message);
 }
 
 // Handles a valid Omaha update check response by matching the results with
 // the registered components which were checked for updates.
 // If updates are found, prepare the components for the actual version upgrade.
 // One of these components will be drafted for the upgrade next time
 // ProcessPendingItems is called.
 void CrxUpdateService::OnUpdateCheckSucceeded(
-    const component_updater::UpdateResponse::Results& results) {
+    const UpdateResponse::Results& results) {
   size_t num_updates_pending = 0;
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  std::vector<component_updater::UpdateResponse::Result>::const_iterator it;
+  std::vector<UpdateResponse::Result>::const_iterator it;
   for (it = results.list.begin(); it != results.list.end(); ++it) {
     CrxUpdateItem* crx = FindUpdateItemById(it->extension_id);
     if (!crx)
       continue;
 
     if (crx->status != CrxUpdateItem::kChecking) {
       NOTREACHED();
       continue;  // Not updating this component now.
     }
 
@@ skipping 19 matching lines @@
 
     if (it->manifest.packages.size() != 1) {
       // Assume one and only one package per component.
       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);
 
-    typedef component_updater::
-        UpdateResponse::Result::Manifest::Package Package;
+    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));
       if (url.is_valid())
          crx->crx_urls.push_back(url);
     }
     for (size_t i = 0; i != it->crx_diffurls.size(); ++i) {
@@ skipping 95 matching lines @@
 // |unpacker|. If there is an error this function is in charge of deleting
 // the files created.
 void CrxUpdateService::Install(scoped_ptr<CRXContext> context,
                                const base::FilePath& crx_path) {
   // This function owns the file at |crx_path| and the |context| object.
   ComponentUnpacker unpacker(context->pk_hash,
                              crx_path,
                              context->fingerprint,
                              component_patcher_.get(),
                              context->installer);
-  if (!component_updater::DeleteFileAndEmptyParentDirectory(crx_path))
+  if (!DeleteFileAndEmptyParentDirectory(crx_path))
     NOTREACHED() << crx_path.value();
 
   // Why unretained? See comment at top of file.
   BrowserThread::PostDelayedTask(
       BrowserThread::UI,
       FROM_HERE,
       base::Bind(&CrxUpdateService::DoneInstalling, base::Unretained(this),
                  context->id, unpacker.error(), unpacker.extended_error()),
       base::TimeDelta::FromMilliseconds(config_->StepDelay()));
 }
@@ skipping 125 matching lines @@
 }
 
 // The component update factory. Using the component updater as a singleton
 // is the job of the browser process.
 ComponentUpdateService* ComponentUpdateServiceFactory(
     ComponentUpdateService::Configurator* config) {
   DCHECK(config);
   return new CrxUpdateService(config);
 }
 
+}  // namespace component_updater
+