Revert of Implement common code for component and extension updaters. (patchset #3 id:40001 of https://codereview.chromium.org/1055903003/)

Reason for revert:
Performance regression: chrome-si/initializers (14.29%)

http://build.chromium.org/p/chromium/builders/Linux%20x64/builds/1504/steps/sizes/logs/stdio

# Static initializers in src/out/Release/chrome:
# HINT: To get this list, run tools/linux/dump-static-initializers.py
# HINT: diff against the log from the last run to see what changed
# atomicops_internals_x86.cc .L.str
# atomicops_internals_x86.cc _GLOBAL__sub_I_atomicops_internals_x86.cc+0x78
# atomicops_internals_x86.cc _GLOBAL__sub_I_atomicops_internals_x86.cc+0xed
# atomicops_internals_x86.cc (anonymous namespace)::google_initializer_module_atomicops_x86
# atomicops_internals_x86.cc GoogleInitializer::~GoogleInitializer()
# atomicops_internals_x86.cc __cxa_atexit@plt [registers a dtor to run at exit]
# atomicops_internals_x86.cc __init_array_end+0x3250
# atomicops_internals_x86.cc __init_array_end+0x34f0
# atomicops_internals_x86.cc __stack_chk_fail@plt
# atomicops_internals_x86.cc strcmp@plt
# atomicops_internals_x86_gcc.cc .L.str
# atomicops_internals_x86_gcc.cc _GLOBAL__sub_I_atomicops_internals_x86_gcc.cc+0x69
# atomicops_internals_x86_gcc.cc _GLOBAL__sub_I_atomicops_internals_x86_gcc.cc+0xb5
# atomicops_internals_x86_gcc.cc google::protobuf::internal::AtomicOps_Internalx86CPUFeatures
# atomicops_internals_x86_gcc.cc google::protobuf::internal::AtomicOps_Internalx86CPUFeatures+0x1
# atomicops_internals_x86_gcc.cc __stack_chk_fail@plt
# atomicops_internals_x86_gcc.cc strcmp@plt
# atomicops_internals_x86_gcc.cc .L.str
# atomicops_internals_x86_gcc.cc _GLOBAL__sub_I_atomicops_internals_x86_gcc.cc+0x62
# atomicops_internals_x86_gcc.cc _GLOBAL__sub_I_atomicops_internals_x86_gcc.cc+0x9e
# atomicops_internals_x86_gcc.cc v8::base::AtomicOps_Internalx86CPUFeatures
# atomicops_internals_x86_gcc.cc __stack_chk_fail@plt
# atomicops_internals_x86_gcc.cc strcmp@plt
# component_updater_service.cc std::ios_base::Init::Init()@plt
# component_updater_service.cc std::__ioinit [#includes <iostream>, use <ostream> instead]
# component_updater_service.cc __cxa_atexit@plt [registers a dtor to run at exit]
# component_updater_service.cc __init_array_end+0x34f0
# component_updater_service.cc __init_array_end+0x4608
# debugallocation_shim.cc module_enter_exit_hook
# debugallocation_shim.cc (anonymous namespace)::large_alloc_threshold
# debugallocation_shim.cc TCMallocGuard::TCMallocGuard()
# debugallocation_shim.cc __cxa_atexit@plt [registers a dtor to run at exit]
# debugallocation_shim.cc __init_array_end+0x34e8
# debugallocation_shim.cc __init_array_end+0x34f0
# debugallocation_shim.cc __init_array_end+0x34f8
# memory_region_map.cc libpthread_initialized
# spinlock.cc _GLOBAL__sub_I_spinlock.cc+0x12
# spinlock.cc NumCPUs()
# spinlock.cc adaptive_spin_count
# spinlock_internal.cc _GLOBAL__sub_I_spinlock_internal.cc+0x79
# spinlock_internal.cc have_futex
# spinlock_internal.cc futex_private_flag
# spinlock_internal.cc syscall@plt
# Found 43 static initializers in 8 files.

Original issue's description:
> Implement common code for component and extension updaters.
>
> The changes not under update_client are mechanical.
>
> This change creates a working UpdateClient updater client, which can be reused by both component and extension updaters.
>
> This code is not hooked up yet with any of the updaters above.
> Those changes will be committed in the near future by other CLs.
>
> R=waffles,erikwright,agl,dgarrett,jhawkins,brettw
>
> BUG=450337
>
> Committed: https://crrev.com/ba6742df55de47568e3aa438378d844a7439c391
> Cr-Commit-Position: refs/heads/master@{#325006}

TBR=agl@chromium.org,dgarrett@chromium.org,erikwright@chromium.org,waffles@chromium.org,dgarrett@google.com,jhawkins@chromium.org,brettw@chromium.org,wfh@chromium.org,sorin@chromium.org
NOPRESUBMIT=true
NOTREECHECKS=true
NOTRY=true
BUG=450337

Review URL: https://codereview.chromium.org/1085643003

Cr-Commit-Position: refs/heads/master@{#325015}

39 files changed, 106 insertions, 3558 deletions

diff --git a/components/update_client/BUILD.gn b/components/update_client/BUILD.gn
index 17665721..c968b4d 100644
--- a/components/update_client/BUILD.gn
+++ b/components/update_client/BUILD.gn
@@ -4,14 +4,6 @@
 
 source_set("update_client") {
   sources = [
-    "action.cc",
-    "action.h",
-    "action_update.cc",
-    "action_update.h",
-    "action_update_check.cc",
-    "action_update_check.h",
-    "action_wait.cc",
-    "action_wait.h",
     "background_downloader_win.cc",
     "background_downloader_win.h",
     "component_patcher.cc",
@@ -28,16 +20,10 @@ source_set("update_client") {
     "ping_manager.h",
     "request_sender.cc",
     "request_sender.h",
-    "task.h",
-    "task_update.cc",
-    "task_update.h",
     "update_checker.cc",
     "update_checker.h",
     "update_client.cc",
     "update_client.h",
-    "update_client_internal.h",
-    "update_engine.cc",
-    "update_engine.h",
     "update_query_params.cc",
     "update_query_params.h",
     "update_query_params_delegate.cc",
@@ -91,7 +77,6 @@ source_set("unit_tests") {
     "test/ping_manager_unittest.cc",
     "test/request_sender_unittest.cc",
     "test/update_checker_unittest.cc",
-    "test/update_client_unittest.cc",
     "test/update_response_unittest.cc",
   ]
 
diff --git a/components/update_client/action.cc b/components/update_client/action.cc
deleted file mode 100644
index 4a11efe..0000000
--- a/components/update_client/action.cc
+++ /dev/null
@@ -1,165 +0,0 @@
-// Copyright 2015 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/action.h"
-
-#include <algorithm>
-#include "base/bind.h"
-#include "base/bind_helpers.h"
-#include "base/callback.h"
-#include "base/location.h"
-#include "base/memory/ref_counted.h"
-#include "base/single_thread_task_runner.h"
-#include "base/thread_task_runner_handle.h"
-#include "components/update_client/action_update.h"
-#include "components/update_client/action_wait.h"
-#include "components/update_client/configurator.h"
-#include "components/update_client/update_engine.h"
-#include "components/update_client/utils.h"
-
-namespace update_client {
-
-namespace {
-
-// Returns true if a differential update is available, it has not failed yet,
-// and the configuration allows this update.
-bool CanTryDiffUpdate(const CrxUpdateItem* update_item,
-                      const scoped_refptr<Configurator>& config) {
-  return HasDiffUpdate(update_item) && !update_item->diff_update_failed &&
-         config->DeltasEnabled();
-}
-
-}  // namespace
-
-ActionImpl::ActionImpl() : update_context_(nullptr) {
-}
-
-ActionImpl::~ActionImpl() {
-  DCHECK(thread_checker_.CalledOnValidThread());
-}
-
-void ActionImpl::Run(UpdateContext* update_context, Action::Callback callback) {
-  DCHECK(thread_checker_.CalledOnValidThread());
-
-  update_context_ = update_context;
-  callback_ = callback;
-}
-
-CrxUpdateItem* ActionImpl::FindUpdateItemById(const std::string& id) const {
-  DCHECK(thread_checker_.CalledOnValidThread());
-
-  const auto it(std::find_if(
-      update_context_->update_items.begin(),
-      update_context_->update_items.end(),
-      [&id](const CrxUpdateItem* item) { return item->id == id; }));
-
-  return it != update_context_->update_items.end() ? *it : nullptr;
-}
-
-void ActionImpl::ChangeItemState(CrxUpdateItem* item, CrxUpdateItem::State to) {
-  DCHECK(thread_checker_.CalledOnValidThread());
-
-  item->state = to;
-
-  using Events = UpdateClient::Observer::Events;
-
-  const std::string& id(item->id);
-  switch (to) {
-    case CrxUpdateItem::State::kChecking:
-      NotifyObservers(Events::COMPONENT_CHECKING_FOR_UPDATES, id);
-      break;
-    case CrxUpdateItem::State::kCanUpdate:
-      NotifyObservers(Events::COMPONENT_UPDATE_FOUND, id);
-      break;
-    case CrxUpdateItem::State::kUpdatingDiff:
-    case CrxUpdateItem::State::kUpdating:
-      NotifyObservers(Events::COMPONENT_UPDATE_READY, id);
-      break;
-    case CrxUpdateItem::State::kUpdated:
-      NotifyObservers(Events::COMPONENT_UPDATED, id);
-      break;
-    case CrxUpdateItem::State::kUpToDate:
-    case CrxUpdateItem::State::kNoUpdate:
-      NotifyObservers(Events::COMPONENT_NOT_UPDATED, id);
-      break;
-    case CrxUpdateItem::State::kNew:
-    case CrxUpdateItem::State::kDownloading:
-    case CrxUpdateItem::State::kDownloadingDiff:
-    case CrxUpdateItem::State::kDownloaded:
-    case CrxUpdateItem::State::kLastStatus:
-      // No notification for these states.
-      break;
-  }
-}
-
-size_t ActionImpl::ChangeAllItemsState(CrxUpdateItem::State from,
-                                       CrxUpdateItem::State to) {
-  DCHECK(thread_checker_.CalledOnValidThread());
-  size_t count = 0;
-  for (auto item : update_context_->update_items) {
-    if (item->state == from) {
-      ChangeItemState(item, to);
-      ++count;
-    }
-  }
-  return count;
-}
-
-void ActionImpl::NotifyObservers(UpdateClient::Observer::Events event,
-                                 const std::string& id) {
-  DCHECK(thread_checker_.CalledOnValidThread());
-  update_context_->notify_observers_callback.Run(event, id);
-}
-
-void ActionImpl::UpdateCrx() {
-  DCHECK(thread_checker_.CalledOnValidThread());
-  DCHECK(!update_context_->queue.empty());
-
-  const std::string& id = update_context_->queue.front();
-  CrxUpdateItem* item = FindUpdateItemById(id);
-  DCHECK(item);
-
-  scoped_ptr<Action> update_action(
-      CanTryDiffUpdate(item, update_context_->config)
-          ? ActionUpdateDiff::Create()
-          : ActionUpdateFull::Create());
-
-  base::ThreadTaskRunnerHandle::Get()->PostTask(
-      FROM_HERE, base::Bind(&Action::Run, base::Unretained(update_action.get()),
-                            update_context_, callback_));
-
-  update_context_->current_action.reset(update_action.release());
-}
-
-void ActionImpl::UpdateCrxComplete(CrxUpdateItem* item) {
-  update_context_->ping_manager->OnUpdateComplete(item);
-
-  update_context_->queue.pop();
-
-  if (update_context_->queue.empty()) {
-    UpdateComplete(0);
-  } else {
-    // TODO(sorin): the value of timing interval between CRX updates might have
-    // to be injected at the call site of update_client::UpdateClient::Update.
-    const int wait_sec = update_context_->config->UpdateDelay();
-
-    scoped_ptr<ActionWait> action_wait(
-        new ActionWait(base::TimeDelta::FromSeconds(wait_sec)));
-
-    base::ThreadTaskRunnerHandle::Get()->PostTask(
-        FROM_HERE, base::Bind(&Action::Run, base::Unretained(action_wait.get()),
-                              update_context_, callback_));
-
-    update_context_->current_action.reset(action_wait.release());
-  }
-}
-
-void ActionImpl::UpdateComplete(int error) {
-  DCHECK(thread_checker_.CalledOnValidThread());
-
-  base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
-                                                base::Bind(callback_, error));
-}
-
-}  // namespace update_client
diff --git a/components/update_client/action.h b/components/update_client/action.h
deleted file mode 100644
index d85e868..0000000
--- a/components/update_client/action.h
+++ /dev/null
@@ -1,98 +0,0 @@
-// Copyright 2015 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.
-
-#ifndef COMPONENTS_UPDATE_CLIENT_ACTION_H_
-#define COMPONENTS_UPDATE_CLIENT_ACTION_H_
-
-#include <string>
-
-#include "base/callback.h"
-#include "base/macros.h"
-#include "base/threading/thread_checker.h"
-#include "components/update_client/crx_update_item.h"
-#include "components/update_client/update_client.h"
-
-namespace update_client {
-
-class Configurator;
-struct CrxUpdateItem;
-struct UpdateContext;
-
-// Any update can be broken down as a sequence of discrete steps, such as
-// checking for updates, downloading patches, updating, and waiting between
-// successive updates. An action is the smallest unit of work executed by
-// the update engine.
-//
-// Defines an abstract interface for a unit of work, executed by the
-// update engine as part of an update.
-class Action {
- public:
-  enum class ErrorCategory {
-    kErrorNone = 0,
-    kNetworkError,
-    kUnpackError,
-    kInstallError,
-    kServiceError,  // Runtime errors which occur in the service itself.
-  };
-
-  enum class ServiceError {
-    ERROR_WAIT = 1,
-  };
-
-  using Callback = base::Callback<void(int error)>;
-  virtual ~Action() {}
-
-  // Runs the code encapsulated by the action. When an action completes, it can
-  // chain up and transfer the execution flow to another action or it can
-  // invoke the |callback| when this function has completed and there is nothing
-  // else to do.
-  virtual void Run(UpdateContext* update_context, Callback callback) = 0;
-};
-
-// Provides a reusable implementation of common functions needed by actions.
-class ActionImpl {
- protected:
-  ActionImpl();
-  ~ActionImpl();
-
-  void Run(UpdateContext* update_context, Action::Callback callback);
-
-  // Changes the current state of the |item| to the new state |to|.
-  void ChangeItemState(CrxUpdateItem* item, CrxUpdateItem::State to);
-
-  // Changes the state of all items in |update_context_|. Returns the count
-  // of items affected by the call.
-  size_t ChangeAllItemsState(CrxUpdateItem::State from,
-                             CrxUpdateItem::State to);
-
-  // Returns the item associated with the component |id| or nullptr in case
-  // of errors.
-  CrxUpdateItem* FindUpdateItemById(const std::string& id) const;
-
-  void NotifyObservers(UpdateClient::Observer::Events event,
-                       const std::string& id);
-
-  // Updates the CRX at the front of the CRX queue in this update context.
-  void UpdateCrx();
-
-  // Completes updating the CRX at the front of the queue, and initiates
-  // the update for the next CRX in the queue, if the queue is not empty.
-  void UpdateCrxComplete(CrxUpdateItem* item);
-
-  // Called when the updates for all CRXs have finished and the execution
-  // flow must return back to the update engine.
-  void UpdateComplete(int error);
-
-  base::ThreadChecker thread_checker_;
-
-  UpdateContext* update_context_;  // Not owned by this class.
-  Action::Callback callback_;
-
- private:
-  DISALLOW_COPY_AND_ASSIGN(ActionImpl);
-};
-
-}  // namespace update_client
-
-#endif  // COMPONENTS_UPDATE_CLIENT_ACTION_H_
diff --git a/components/update_client/action_update.cc b/components/update_client/action_update.cc
deleted file mode 100644
index b43820b..0000000
--- a/components/update_client/action_update.cc
+++ /dev/null
@@ -1,370 +0,0 @@
-// Copyright 2015 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/action_update.h"
-
-#include <vector>
-
-#include "base/bind.h"
-#include "base/bind_helpers.h"
-#include "base/callback.h"
-#include "base/location.h"
-#include "base/logging.h"
-#include "base/single_thread_task_runner.h"
-#include "base/thread_task_runner_handle.h"
-#include "base/time/time.h"
-#include "base/version.h"
-#include "components/update_client/configurator.h"
-#include "components/update_client/crx_downloader.h"
-#include "components/update_client/update_client.h"
-#include "components/update_client/utils.h"
-
-using std::string;
-using std::vector;
-
-namespace update_client {
-
-namespace {
-
-void AppendDownloadMetrics(
-    const std::vector<CrxDownloader::DownloadMetrics>& source,
-    std::vector<CrxDownloader::DownloadMetrics>* destination) {
-  destination->insert(destination->end(), source.begin(), source.end());
-}
-
-Action::ErrorCategory UnpackerErrorToErrorCategory(
-    ComponentUnpacker::Error error) {
-  Action::ErrorCategory error_category = Action::ErrorCategory::kErrorNone;
-  switch (error) {
-    case ComponentUnpacker::kNone:
-      break;
-    case ComponentUnpacker::kInstallerError:
-      error_category = Action::ErrorCategory::kInstallError;
-      break;
-    default:
-      error_category = Action::ErrorCategory::kUnpackError;
-      break;
-  }
-  return error_category;
-}
-
-}  // namespace
-
-ActionUpdate::ActionUpdate() {
-}
-
-ActionUpdate::~ActionUpdate() {
-  DCHECK(thread_checker_.CalledOnValidThread());
-}
-
-void ActionUpdate::Run(UpdateContext* update_context, Callback callback) {
-  DCHECK(thread_checker_.CalledOnValidThread());
-  ActionImpl::Run(update_context, callback);
-
-  DCHECK(!update_context_->queue.empty());
-
-  const std::string& id = update_context_->queue.front();
-  CrxUpdateItem* item = FindUpdateItemById(id);
-  DCHECK(item);
-
-  const bool is_background_download(IsBackgroundDownload(item));
-
-  scoped_ptr<CrxDownloader> crx_downloader(
-      (*update_context_->crx_downloader_factory)(
-          is_background_download, update_context_->config->RequestContext(),
-          update_context_->blocking_task_runner,
-          update_context_->single_thread_task_runner));
-  crx_downloader->set_progress_callback(
-      base::Bind(&ActionUpdate::DownloadProgress, base::Unretained(this), id));
-  update_context_->crx_downloader.reset(crx_downloader.release());
-
-  const std::vector<GURL> urls(GetUrls(item));
-  OnDownloadStart(item);
-
-  update_context_->crx_downloader->StartDownload(
-      urls,
-      base::Bind(&ActionUpdate::DownloadComplete, base::Unretained(this), id));
-}
-
-void ActionUpdate::DownloadProgress(
-    const std::string& crx_id,
-    const CrxDownloader::Result& download_result) {
-  DCHECK(thread_checker_.CalledOnValidThread());
-  DCHECK(crx_id == update_context_->queue.front());
-
-  using Events = UpdateClient::Observer::Events;
-  NotifyObservers(Events::COMPONENT_UPDATE_DOWNLOADING, crx_id);
-}
-
-void ActionUpdate::DownloadComplete(
-    const std::string& crx_id,
-    const CrxDownloader::Result& download_result) {
-  DCHECK(thread_checker_.CalledOnValidThread());
-  DCHECK(crx_id == update_context_->queue.front());
-
-  CrxUpdateItem* item = FindUpdateItemById(crx_id);
-  DCHECK(item);
-
-  AppendDownloadMetrics(update_context_->crx_downloader->download_metrics(),
-                        &item->download_metrics);
-
-  if (download_result.error) {
-    OnDownloadError(item, download_result);
-  } else {
-    OnDownloadSuccess(item, download_result);
-    update_context_->main_task_runner->PostDelayedTask(
-        FROM_HERE, base::Bind(&ActionUpdate::Install, base::Unretained(this),
-                              crx_id, download_result.response),
-        base::TimeDelta::FromMilliseconds(
-            update_context_->config->StepDelay()));
-  }
-
-  update_context_->crx_downloader.reset();
-}
-
-void ActionUpdate::Install(const std::string& crx_id,
-                           const base::FilePath& crx_path) {
-  DCHECK(thread_checker_.CalledOnValidThread());
-  DCHECK(crx_id == update_context_->queue.front());
-
-  CrxUpdateItem* item = FindUpdateItemById(crx_id);
-  DCHECK(item);
-
-  OnInstallStart(item);
-
-  update_context_->blocking_task_runner->PostTask(
-      FROM_HERE,
-      base::Bind(&ActionUpdate::DoInstallOnBlockingTaskRunner,
-                 base::Unretained(this), update_context_, item, crx_path));
-}
-
-void ActionUpdate::DoInstallOnBlockingTaskRunner(
-    UpdateContext* update_context,
-    CrxUpdateItem* item,
-    const base::FilePath& crx_path) {
-  update_context->unpacker = new ComponentUnpacker(
-      item->component.pk_hash, crx_path, item->component.fingerprint,
-      item->component.installer,
-      update_context->config->CreateOutOfProcessPatcher(),
-      update_context->blocking_task_runner);
-  update_context->unpacker->Unpack(
-      base::Bind(&ActionUpdate::EndUnpackingOnBlockingTaskRunner,
-                 base::Unretained(this), update_context, item, crx_path));
-}
-
-void ActionUpdate::EndUnpackingOnBlockingTaskRunner(
-    UpdateContext* update_context,
-    CrxUpdateItem* item,
-    const base::FilePath& crx_path,
-    ComponentUnpacker::Error error,
-    int extended_error) {
-  update_client::DeleteFileAndEmptyParentDirectory(crx_path);
-  update_context->main_task_runner->PostDelayedTask(
-      FROM_HERE,
-      base::Bind(&ActionUpdate::DoneInstalling, base::Unretained(this),
-                 item->id, error, extended_error),
-      base::TimeDelta::FromMilliseconds(update_context->config->StepDelay()));
-
-  // Reset the unpacker last, otherwise we free our own arguments.
-  update_context->unpacker = nullptr;
-}
-
-void ActionUpdate::DoneInstalling(const std::string& crx_id,
-                                  ComponentUnpacker::Error error,
-                                  int extended_error) {
-  DCHECK(thread_checker_.CalledOnValidThread());
-  DCHECK(crx_id == update_context_->queue.front());
-
-  CrxUpdateItem* item = FindUpdateItemById(crx_id);
-  DCHECK(item);
-
-  if (error == ComponentUnpacker::kNone)
-    OnInstallSuccess(item);
-  else
-    OnInstallError(item, error, extended_error);
-}
-
-ActionUpdateDiff::ActionUpdateDiff() {
-}
-
-ActionUpdateDiff::~ActionUpdateDiff() {
-  DCHECK(thread_checker_.CalledOnValidThread());
-}
-
-scoped_ptr<Action> ActionUpdateDiff::Create() {
-  return scoped_ptr<Action>(new ActionUpdateDiff);
-}
-
-void ActionUpdateDiff::TryUpdateFull() {
-  DCHECK(thread_checker_.CalledOnValidThread());
-  scoped_ptr<Action> update_action(ActionUpdateFull::Create());
-
-  base::ThreadTaskRunnerHandle::Get()->PostTask(
-      FROM_HERE, base::Bind(&Action::Run, base::Unretained(update_action.get()),
-                            update_context_, callback_));
-
-  update_context_->current_action.reset(update_action.release());
-}
-
-bool ActionUpdateDiff::IsBackgroundDownload(const CrxUpdateItem* item) {
-  DCHECK(thread_checker_.CalledOnValidThread());
-  return false;
-}
-
-std::vector<GURL> ActionUpdateDiff::GetUrls(const CrxUpdateItem* item) {
-  DCHECK(thread_checker_.CalledOnValidThread());
-  return item->crx_diffurls;
-}
-
-void ActionUpdateDiff::OnDownloadStart(CrxUpdateItem* item) {
-  DCHECK(thread_checker_.CalledOnValidThread());
-  DCHECK(item->state == CrxUpdateItem::State::kCanUpdate);
-
-  ChangeItemState(item, CrxUpdateItem::State::kDownloadingDiff);
-}
-
-void ActionUpdateDiff::OnDownloadSuccess(
-    CrxUpdateItem* item,
-    const CrxDownloader::Result& download_result) {
-  DCHECK(thread_checker_.CalledOnValidThread());
-  DCHECK(item->state == CrxUpdateItem::State::kDownloadingDiff);
-
-  ChangeItemState(item, CrxUpdateItem::State::kDownloaded);
-}
-
-void ActionUpdateDiff::OnDownloadError(
-    CrxUpdateItem* item,
-    const CrxDownloader::Result& download_result) {
-  DCHECK(thread_checker_.CalledOnValidThread());
-  DCHECK(item->state == CrxUpdateItem::State::kDownloadingDiff);
-
-  item->diff_error_category = static_cast<int>(ErrorCategory::kNetworkError);
-  item->diff_error_code = download_result.error;
-  item->diff_update_failed = true;
-
-  base::ThreadTaskRunnerHandle::Get()->PostTask(
-      FROM_HERE,
-      base::Bind(&ActionUpdateDiff::TryUpdateFull, base::Unretained(this)));
-}
-
-void ActionUpdateDiff::OnInstallStart(CrxUpdateItem* item) {
-  DCHECK(thread_checker_.CalledOnValidThread());
-
-  ChangeItemState(item, CrxUpdateItem::State::kUpdatingDiff);
-}
-
-void ActionUpdateDiff::OnInstallSuccess(CrxUpdateItem* item) {
-  DCHECK(thread_checker_.CalledOnValidThread());
-  DCHECK(item->state == CrxUpdateItem::State::kUpdatingDiff);
-
-  item->component.version = item->next_version;
-  item->component.fingerprint = item->next_fp;
-  ChangeItemState(item, CrxUpdateItem::State::kUpdated);
-
-  UpdateCrxComplete(item);
-}
-
-void ActionUpdateDiff::OnInstallError(CrxUpdateItem* item,
-                                      ComponentUnpacker::Error error,
-                                      int extended_error) {
-  DCHECK(thread_checker_.CalledOnValidThread());
-
-  item->diff_error_category =
-      static_cast<int>(UnpackerErrorToErrorCategory(error));
-  item->diff_error_code = error;
-  item->diff_extra_code1 = extended_error;
-  item->diff_update_failed = true;
-
-  base::ThreadTaskRunnerHandle::Get()->PostTask(
-      FROM_HERE,
-      base::Bind(&ActionUpdateDiff::TryUpdateFull, base::Unretained(this)));
-}
-
-ActionUpdateFull::ActionUpdateFull() {
-}
-
-ActionUpdateFull::~ActionUpdateFull() {
-  DCHECK(thread_checker_.CalledOnValidThread());
-}
-
-scoped_ptr<Action> ActionUpdateFull::Create() {
-  return scoped_ptr<Action>(new ActionUpdateFull);
-}
-
-bool ActionUpdateFull::IsBackgroundDownload(const CrxUpdateItem* item) {
-  DCHECK(thread_checker_.CalledOnValidThread());
-
-  // On demand component updates are always downloaded in foreground.
-  return !item->on_demand && item->component.allow_background_download &&
-         update_context_->config->UseBackgroundDownloader();
-}
-
-std::vector<GURL> ActionUpdateFull::GetUrls(const CrxUpdateItem* item) {
-  DCHECK(thread_checker_.CalledOnValidThread());
-  return item->crx_urls;
-}
-
-void ActionUpdateFull::OnDownloadStart(CrxUpdateItem* item) {
-  DCHECK(thread_checker_.CalledOnValidThread());
-  DCHECK(item->state == CrxUpdateItem::State::kCanUpdate ||
-         item->diff_update_failed);
-
-  ChangeItemState(item, CrxUpdateItem::State::kDownloading);
-}
-
-void ActionUpdateFull::OnDownloadSuccess(
-    CrxUpdateItem* item,
-    const CrxDownloader::Result& download_result) {
-  DCHECK(thread_checker_.CalledOnValidThread());
-  DCHECK(item->state == CrxUpdateItem::State::kDownloading);
-
-  ChangeItemState(item, CrxUpdateItem::State::kDownloaded);
-}
-
-void ActionUpdateFull::OnDownloadError(
-    CrxUpdateItem* item,
-    const CrxDownloader::Result& download_result) {
-  DCHECK(thread_checker_.CalledOnValidThread());
-  DCHECK(item->state == CrxUpdateItem::State::kDownloading);
-
-  item->error_category = static_cast<int>(ErrorCategory::kNetworkError);
-  item->error_code = download_result.error;
-  ChangeItemState(item, CrxUpdateItem::State::kNoUpdate);
-
-  UpdateCrxComplete(item);
-}
-
-void ActionUpdateFull::OnInstallStart(CrxUpdateItem* item) {
-  DCHECK(thread_checker_.CalledOnValidThread());
-  DCHECK(item->state == CrxUpdateItem::State::kDownloaded);
-
-  ChangeItemState(item, CrxUpdateItem::State::kUpdating);
-}
-
-void ActionUpdateFull::OnInstallSuccess(CrxUpdateItem* item) {
-  DCHECK(thread_checker_.CalledOnValidThread());
-  DCHECK(item->state == CrxUpdateItem::State::kUpdating);
-
-  item->component.version = item->next_version;
-  item->component.fingerprint = item->next_fp;
-  ChangeItemState(item, CrxUpdateItem::State::kUpdated);
-
-  UpdateCrxComplete(item);
-}
-
-void ActionUpdateFull::OnInstallError(CrxUpdateItem* item,
-                                      ComponentUnpacker::Error error,
-                                      int extended_error) {
-  DCHECK(thread_checker_.CalledOnValidThread());
-  DCHECK(item->state == CrxUpdateItem::State::kUpdating);
-
-  item->error_category = static_cast<int>(UnpackerErrorToErrorCategory(error));
-  item->error_code = error;
-  item->extra_code1 = extended_error;
-  ChangeItemState(item, CrxUpdateItem::State::kNoUpdate);
-
-  UpdateCrxComplete(item);
-}
-
-}  // namespace update_client
diff --git a/components/update_client/action_update.h b/components/update_client/action_update.h
deleted file mode 100644
index 8b33444..0000000
--- a/components/update_client/action_update.h
+++ /dev/null
@@ -1,138 +0,0 @@
-// Copyright 2015 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.
-
-#ifndef COMPONENTS_UPDATE_CLIENT_ACTION_UPDATE_H_
-#define COMPONENTS_UPDATE_CLIENT_ACTION_UPDATE_H_
-
-#include <map>
-#include <string>
-#include <vector>
-
-#include "base/macros.h"
-#include "base/memory/scoped_ptr.h"
-#include "base/threading/thread_checker.h"
-#include "base/version.h"
-#include "components/update_client/action.h"
-#include "components/update_client/component_unpacker.h"
-#include "components/update_client/update_client.h"
-#include "components/update_client/update_engine.h"
-#include "url/gurl.h"
-
-namespace update_client {
-
-class UpdateChecker;
-
-// Defines a template method design pattern for ActionUpdate. This class
-// implements the common code for updating a CRX using either differential or
-// full updates algorithm.
-class ActionUpdate : public Action, protected ActionImpl {
- public:
-  ActionUpdate();
-  ~ActionUpdate() override;
-
-  // Action overrides.
-  void Run(UpdateContext* update_context, Callback callback) override;
-
- private:
-  virtual bool IsBackgroundDownload(const CrxUpdateItem* item) = 0;
-  virtual std::vector<GURL> GetUrls(const CrxUpdateItem* item) = 0;
-  virtual void OnDownloadStart(CrxUpdateItem* item) = 0;
-  virtual void OnDownloadSuccess(
-      CrxUpdateItem* item,
-      const CrxDownloader::Result& download_result) = 0;
-  virtual void OnDownloadError(
-      CrxUpdateItem* item,
-      const CrxDownloader::Result& download_result) = 0;
-  virtual void OnInstallStart(CrxUpdateItem* item) = 0;
-  virtual void OnInstallSuccess(CrxUpdateItem* item) = 0;
-  virtual void OnInstallError(CrxUpdateItem* item,
-                              ComponentUnpacker::Error error,
-                              int extended_error) = 0;
-
-  // Called when progress is being made downloading a CRX. The progress may
-  // not monotonically increase due to how the CRX downloader switches between
-  // different downloaders and fallback urls.
-  void DownloadProgress(const std::string& crx_id,
-                        const CrxDownloader::Result& download_result);
-
-  // Called when the CRX package has been downloaded to a temporary location.
-  void DownloadComplete(const std::string& crx_id,
-                        const CrxDownloader::Result& download_result);
-
-  void Install(const std::string& crx_id, const base::FilePath& crx_path);
-
-  // TODO(sorin): refactor the public interface of ComponentUnpacker so
-  // that these calls can run on the main thread.
-  void DoInstallOnBlockingTaskRunner(UpdateContext* update_context,
-                                     CrxUpdateItem* item,
-                                     const base::FilePath& crx_path);
-
-  void EndUnpackingOnBlockingTaskRunner(UpdateContext* update_context,
-                                        CrxUpdateItem* item,
-                                        const base::FilePath& crx_path,
-                                        ComponentUnpacker::Error error,
-                                        int extended_error);
-
-  void DoneInstalling(const std::string& crx_id,
-                      ComponentUnpacker::Error error,
-                      int extended_error);
-
-  DISALLOW_COPY_AND_ASSIGN(ActionUpdate);
-};
-
-class ActionUpdateDiff : public ActionUpdate {
- public:
-  static scoped_ptr<Action> Create();
-
- private:
-  ActionUpdateDiff();
-  ~ActionUpdateDiff() override;
-
-  void TryUpdateFull();
-
-  // ActionUpdate overrides.
-  bool IsBackgroundDownload(const CrxUpdateItem* item) override;
-  std::vector<GURL> GetUrls(const CrxUpdateItem* item) override;
-  void OnDownloadStart(CrxUpdateItem* item) override;
-  void OnDownloadSuccess(CrxUpdateItem* item,
-                         const CrxDownloader::Result& download_result) override;
-  void OnDownloadError(CrxUpdateItem* item,
-                       const CrxDownloader::Result& download_result) override;
-  void OnInstallStart(CrxUpdateItem* item) override;
-  void OnInstallSuccess(CrxUpdateItem* item) override;
-  void OnInstallError(CrxUpdateItem* item,
-                      ComponentUnpacker::Error error,
-                      int extended_error) override;
-
-  DISALLOW_COPY_AND_ASSIGN(ActionUpdateDiff);
-};
-
-class ActionUpdateFull : ActionUpdate {
- public:
-  static scoped_ptr<Action> Create();
-
- private:
-  ActionUpdateFull();
-  ~ActionUpdateFull() override;
-
-  // ActionUpdate overrides.
-  bool IsBackgroundDownload(const CrxUpdateItem* item) override;
-  std::vector<GURL> GetUrls(const CrxUpdateItem* item) override;
-  void OnDownloadStart(CrxUpdateItem* item) override;
-  void OnDownloadSuccess(CrxUpdateItem* item,
-                         const CrxDownloader::Result& download_result) override;
-  void OnDownloadError(CrxUpdateItem* item,
-                       const CrxDownloader::Result& download_result) override;
-  void OnInstallStart(CrxUpdateItem* item) override;
-  void OnInstallSuccess(CrxUpdateItem* item) override;
-  void OnInstallError(CrxUpdateItem* item,
-                      ComponentUnpacker::Error error,
-                      int extended_error) override;
-
-  DISALLOW_COPY_AND_ASSIGN(ActionUpdateFull);
-};
-
-}  // namespace update_client
-
-#endif  // COMPONENTS_UPDATE_CLIENT_ACTION_UPDATE_H_
diff --git a/components/update_client/action_update_check.cc b/components/update_client/action_update_check.cc
deleted file mode 100644
index c480de8..0000000
--- a/components/update_client/action_update_check.cc
+++ /dev/null
@@ -1,204 +0,0 @@
-// Copyright 2015 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/action_update_check.h"
-
-#include "base/bind.h"
-#include "base/bind_helpers.h"
-#include "base/callback.h"
-#include "base/location.h"
-#include "base/logging.h"
-#include "base/single_thread_task_runner.h"
-#include "base/thread_task_runner_handle.h"
-#include "base/version.h"
-#include "components/update_client/action_update.h"
-#include "components/update_client/configurator.h"
-#include "components/update_client/update_checker.h"
-#include "components/update_client/update_client.h"
-#include "components/update_client/utils.h"
-
-using std::string;
-using std::vector;
-
-namespace update_client {
-
-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;
-}
-
-}  // namespace
-
-ActionUpdateCheck::ActionUpdateCheck(
-    scoped_ptr<UpdateChecker> update_checker,
-    const base::Version& browser_version,
-    const std::string& extra_request_parameters)
-    : update_checker_(update_checker.Pass()),
-      browser_version_(browser_version),
-      extra_request_parameters_(extra_request_parameters) {
-}
-
-ActionUpdateCheck::~ActionUpdateCheck() {
-  DCHECK(thread_checker_.CalledOnValidThread());
-}
-
-void ActionUpdateCheck::Run(UpdateContext* update_context, Callback callback) {
-  DCHECK(thread_checker_.CalledOnValidThread());
-
-  ActionImpl::Run(update_context, callback);
-
-  // Calls out to get the corresponding CrxComponent data for the CRXs in this
-  // update context.
-  vector<CrxComponent> crx_components;
-  update_context_->crx_data_callback.Run(update_context_->ids, &crx_components);
-
-  update_context_->update_items.reserve(crx_components.size());
-
-  for (size_t i = 0; i != crx_components.size(); ++i) {
-    scoped_ptr<CrxUpdateItem> item(new CrxUpdateItem);
-    const CrxComponent& crx_component = crx_components[i];
-
-    item->id = GetCrxComponentID(crx_component);
-    item->component = crx_component;
-    item->last_check = base::Time::Now();
-    item->crx_urls.clear();
-    item->crx_diffurls.clear();
-    item->previous_version = crx_component.version;
-    item->next_version = Version();
-    item->previous_fp = crx_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();
-
-    ChangeItemState(item.get(), CrxUpdateItem::State::kChecking);
-
-    update_context_->update_items.push_back(item.release());
-  }
-
-  update_checker_->CheckForUpdates(
-      update_context_->update_items, extra_request_parameters_,
-      base::Bind(&ActionUpdateCheck::UpdateCheckComplete,
-                 base::Unretained(this)));
-}
-
-void ActionUpdateCheck::UpdateCheckComplete(
-    const GURL& original_url,
-    int error,
-    const std::string& error_message,
-    const UpdateResponse::Results& results) {
-  DCHECK(thread_checker_.CalledOnValidThread());
-
-  VLOG(1) << "Update check completed from: " << original_url.spec();
-
-  if (!error)
-    OnUpdateCheckSucceeded(results);
-  else
-    OnUpdateCheckFailed(error, error_message);
-}
-
-void ActionUpdateCheck::OnUpdateCheckSucceeded(
-    const UpdateResponse::Results& results) {
-  DCHECK(thread_checker_.CalledOnValidThread());
-  VLOG(1) << "Update check succeeded.";
-  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->state != CrxUpdateItem::State::kChecking) {
-      NOTREACHED();
-      continue;  // Not updating this CRX now.
-    }
-
-    if (it->manifest.version.empty()) {
-      // No version means no update available.
-      ChangeItemState(crx, CrxUpdateItem::State::kNoUpdate);
-      VLOG(1) << "No update available for CRX: " << crx->id;
-      continue;
-    }
-
-    if (!IsVersionNewer(crx->component.version, it->manifest.version)) {
-      // The CRX is up to date.
-      ChangeItemState(crx, CrxUpdateItem::State::kUpToDate);
-      VLOG(1) << "Component already up-to-date: " << crx->id;
-      continue;
-    }
-
-    if (!it->manifest.browser_min_version.empty()) {
-      if (IsVersionNewer(browser_version_, it->manifest.browser_min_version)) {
-        // The CRX is not compatible with this Chrome version.
-        VLOG(1) << "Ignoring incompatible CRX: " << crx->id;
-        ChangeItemState(crx, CrxUpdateItem::State::kNoUpdate);
-        continue;
-      }
-    }
-
-    if (it->manifest.packages.size() != 1) {
-      // Assume one and only one package per CRX.
-      VLOG(1) << "Ignoring multiple packages for CRX: " << crx->id;
-      ChangeItemState(crx, CrxUpdateItem::State::kNoUpdate);
-      continue;
-    }
-
-    // Parse the members of the result and queue an upgrade for this CRX.
-    crx->next_version = Version(it->manifest.version);
-
-    VLOG(1) << "Update found for CRX: " << crx->id;
-
-    const auto& 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) {
-      const GURL url(it->crx_diffurls[i].Resolve(package.namediff));
-      if (url.is_valid())
-        crx->crx_diffurls.push_back(url);
-    }
-
-    ChangeItemState(crx, CrxUpdateItem::State::kCanUpdate);
-
-    update_context_->queue.push(crx->id);
-  }
-
-  // All components that are not included in the update response are
-  // considered up to date.
-  ChangeAllItemsState(CrxUpdateItem::State::kChecking,
-                      CrxUpdateItem::State::kUpToDate);
-
-  if (update_context_->queue.empty()) {
-    VLOG(1) << "Update check completed but no update is needed.";
-    UpdateComplete(0);
-    return;
-  }
-
-  // Starts the execution flow of updating the CRXs in this context.
-  UpdateCrx();
-}
-
-void ActionUpdateCheck::OnUpdateCheckFailed(int error,
-                                            const std::string& error_message) {
-  DCHECK(thread_checker_.CalledOnValidThread());
-  DCHECK(error);
-
-  VLOG(1) << "Update check failed." << error;
-
-  UpdateComplete(error);
-}
-
-}  // namespace update_client
diff --git a/components/update_client/action_update_check.h b/components/update_client/action_update_check.h
deleted file mode 100644
index b5f1d24..0000000
--- a/components/update_client/action_update_check.h
+++ /dev/null
@@ -1,56 +0,0 @@
-// Copyright 2015 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.
-
-#ifndef COMPONENTS_UPDATE_CLIENT_ACTION_UPDATE_CHECK_H_
-#define COMPONENTS_UPDATE_CLIENT_ACTION_UPDATE_CHECK_H_
-
-#include <map>
-#include <string>
-#include <vector>
-
-#include "base/macros.h"
-#include "base/memory/scoped_ptr.h"
-#include "base/threading/thread_checker.h"
-#include "base/version.h"
-#include "components/update_client/action.h"
-#include "components/update_client/crx_update_item.h"
-#include "components/update_client/update_client.h"
-#include "components/update_client/update_engine.h"
-#include "components/update_client/update_response.h"
-#include "url/gurl.h"
-
-namespace update_client {
-
-class UpdateChecker;
-
-// Implements an update check for the CRXs in an update context.
-class ActionUpdateCheck : public Action, private ActionImpl {
- public:
-  ActionUpdateCheck(scoped_ptr<UpdateChecker> update_checker,
-                    const base::Version& browser_version,
-                    const std::string& extra_request_parameters);
-
-  ~ActionUpdateCheck() override;
-
-  void Run(UpdateContext* update_context, Callback callback) override;
-
- private:
-  void UpdateCheckComplete(const GURL& original_url,
-                           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);
-
-  scoped_ptr<UpdateChecker> update_checker_;
-  const base::Version browser_version_;
-  const std::string extra_request_parameters_;
-
-  DISALLOW_COPY_AND_ASSIGN(ActionUpdateCheck);
-};
-
-}  // namespace update_client
-
-#endif  // COMPONENTS_UPDATE_CLIENT_ACTION_UPDATE_CHECK_H_
diff --git a/components/update_client/action_wait.cc b/components/update_client/action_wait.cc
deleted file mode 100644
index 1e8f8059..0000000
--- a/components/update_client/action_wait.cc
+++ /dev/null
@@ -1,61 +0,0 @@
-// Copyright 2015 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/action_wait.h"
-
-#include "base/bind.h"
-#include "base/bind_helpers.h"
-#include "base/location.h"
-#include "base/single_thread_task_runner.h"
-#include "base/thread_task_runner_handle.h"
-#include "components/update_client/update_engine.h"
-
-namespace update_client {
-
-ActionWait::ActionWait(const base::TimeDelta& time_delta)
-    : time_delta_(time_delta) {
-}
-
-ActionWait::~ActionWait() {
-  DCHECK(thread_checker_.CalledOnValidThread());
-}
-
-void ActionWait::Run(UpdateContext* update_context, Callback callback) {
-  DCHECK(thread_checker_.CalledOnValidThread());
-  DCHECK(update_context);
-
-  ActionImpl::Run(update_context, callback);
-
-  const bool result = base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
-      FROM_HERE, base::Bind(&ActionWait::WaitComplete, base::Unretained(this)),
-      time_delta_);
-
-  if (!result) {
-    // Move all items pending updates to the |kNoUpdate| state then return the
-    // control flow to the update engine, as the updates in this context are
-    // completed with an error.
-    while (!update_context->queue.empty()) {
-      const auto item = FindUpdateItemById(update_context->queue.front());
-      if (!item) {
-        item->error_category = static_cast<int>(ErrorCategory::kServiceError);
-        item->error_code = static_cast<int>(ServiceError::ERROR_WAIT);
-        ChangeItemState(item, CrxUpdateItem::State::kNoUpdate);
-      } else {
-        NOTREACHED();
-      }
-      update_context->queue.pop();
-    }
-    callback.Run(static_cast<int>(ServiceError::ERROR_WAIT));
-  }
-
-  NotifyObservers(UpdateClient::Observer::Events::COMPONENT_WAIT,
-                  update_context_->queue.front());
-}
-
-void ActionWait::WaitComplete() {
-  DCHECK(thread_checker_.CalledOnValidThread());
-  UpdateCrx();
-}
-
-}  // namespace update_client
diff --git a/components/update_client/action_wait.h b/components/update_client/action_wait.h
deleted file mode 100644
index d54062b..0000000
--- a/components/update_client/action_wait.h
+++ /dev/null
@@ -1,36 +0,0 @@
-// Copyright 2015 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.
-
-#ifndef COMPONENTS_UPDATE_CLIENT_ACTION_WAIT_H_
-#define COMPONENTS_UPDATE_CLIENT_ACTION_WAIT_H_
-
-#include "base/callback.h"
-#include "base/macros.h"
-#include "base/time/time.h"
-
-#include "components/update_client/action.h"
-
-namespace update_client {
-
-// Implements a wait between handling updates for the CRXs in this context.
-// To avoid thrashing of local computing resources, updates are applied one
-// at a time, with a delay between them.
-class ActionWait : public Action, protected ActionImpl {
- public:
-  explicit ActionWait(const base::TimeDelta& time_delta);
-  ~ActionWait() override;
-
-  void Run(UpdateContext* update_context, Callback callback) override;
-
- private:
-  void WaitComplete();
-
-  const base::TimeDelta time_delta_;
-
-  DISALLOW_COPY_AND_ASSIGN(ActionWait);
-};
-
-}  // namespace update_client
-
-#endif  // COMPONENTS_UPDATE_CLIENT_ACTION_WAIT_H_
diff --git a/components/update_client/component_patcher.cc b/components/update_client/component_patcher.cc
index 0525882..29ce774 100644
--- a/components/update_client/component_patcher.cc
+++ b/components/update_client/component_patcher.cc
@@ -43,7 +43,7 @@ base::ListValue* ReadCommands(const base::FilePath& unpack_path) {
 ComponentPatcher::ComponentPatcher(
     const base::FilePath& input_dir,
     const base::FilePath& unpack_dir,
-    scoped_refptr<CrxInstaller> installer,
+    scoped_refptr<ComponentInstaller> installer,
     scoped_refptr<OutOfProcessPatcher> out_of_process_patcher,
     scoped_refptr<base::SequencedTaskRunner> task_runner)
     : input_dir_(input_dir),
diff --git a/components/update_client/component_patcher.h b/components/update_client/component_patcher.h
index 23c16c8..394edfe 100644
--- a/components/update_client/component_patcher.h
+++ b/components/update_client/component_patcher.h
@@ -40,7 +40,7 @@ class FilePath;
 
 namespace update_client {
 
-class CrxInstaller;
+class ComponentInstaller;
 class DeltaUpdateOp;
 class OutOfProcessPatcher;
 
@@ -61,7 +61,7 @@ class ComponentPatcher : public base::RefCountedThreadSafe<ComponentPatcher> {
   // out-of-process.
   ComponentPatcher(const base::FilePath& input_dir,
                    const base::FilePath& unpack_dir,
-                   scoped_refptr<CrxInstaller> installer,
+                   scoped_refptr<ComponentInstaller> installer,
                    scoped_refptr<OutOfProcessPatcher> out_of_process_patcher,
                    scoped_refptr<base::SequencedTaskRunner> task_runner);
 
@@ -86,7 +86,7 @@ class ComponentPatcher : public base::RefCountedThreadSafe<ComponentPatcher> {
 
   const base::FilePath input_dir_;
   const base::FilePath unpack_dir_;
-  scoped_refptr<CrxInstaller> installer_;
+  scoped_refptr<ComponentInstaller> installer_;
   scoped_refptr<OutOfProcessPatcher> out_of_process_patcher_;
   ComponentUnpacker::Callback callback_;
   scoped_ptr<base::ListValue> commands_;
diff --git a/components/update_client/component_patcher_operation.cc b/components/update_client/component_patcher_operation.cc
index e971533..c5e7437 100644
--- a/components/update_client/component_patcher_operation.cc
+++ b/components/update_client/component_patcher_operation.cc
@@ -64,7 +64,7 @@ void DeltaUpdateOp::Run(
     const base::DictionaryValue* command_args,
     const base::FilePath& input_dir,
     const base::FilePath& unpack_dir,
-    const scoped_refptr<CrxInstaller>& installer,
+    const scoped_refptr<ComponentInstaller>& installer,
     const ComponentUnpacker::Callback& callback,
     const scoped_refptr<base::SequencedTaskRunner>& task_runner) {
   callback_ = callback;
@@ -141,7 +141,7 @@ DeltaUpdateOpCopy::~DeltaUpdateOpCopy() {
 ComponentUnpacker::Error DeltaUpdateOpCopy::DoParseArguments(
     const base::DictionaryValue* command_args,
     const base::FilePath& input_dir,
-    const scoped_refptr<CrxInstaller>& installer) {
+    const scoped_refptr<ComponentInstaller>& installer) {
   std::string input_rel_path;
   if (!command_args->GetString(kInput, &input_rel_path))
     return ComponentUnpacker::kDeltaBadCommands;
@@ -168,7 +168,7 @@ DeltaUpdateOpCreate::~DeltaUpdateOpCreate() {
 ComponentUnpacker::Error DeltaUpdateOpCreate::DoParseArguments(
     const base::DictionaryValue* command_args,
     const base::FilePath& input_dir,
-    const scoped_refptr<CrxInstaller>& installer) {
+    const scoped_refptr<ComponentInstaller>& installer) {
   std::string patch_rel_path;
   if (!command_args->GetString(kPatch, &patch_rel_path))
     return ComponentUnpacker::kDeltaBadCommands;
@@ -199,7 +199,7 @@ DeltaUpdateOpPatch::~DeltaUpdateOpPatch() {
 ComponentUnpacker::Error DeltaUpdateOpPatch::DoParseArguments(
     const base::DictionaryValue* command_args,
     const base::FilePath& input_dir,
-    const scoped_refptr<CrxInstaller>& installer) {
+    const scoped_refptr<ComponentInstaller>& installer) {
   std::string patch_rel_path;
   std::string input_rel_path;
   if (!command_args->GetString(kPatch, &patch_rel_path) ||
diff --git a/components/update_client/component_patcher_operation.h b/components/update_client/component_patcher_operation.h
index 1cb09e3..0771757 100644
--- a/components/update_client/component_patcher_operation.h
+++ b/components/update_client/component_patcher_operation.h
@@ -26,7 +26,7 @@ extern const char kCourgette[];
 extern const char kInput[];
 extern const char kPatch[];
 
-class CrxInstaller;
+class ComponentInstaller;
 
 class DeltaUpdateOp : public base::RefCountedThreadSafe<DeltaUpdateOp> {
  public:
@@ -37,7 +37,7 @@ class DeltaUpdateOp : public base::RefCountedThreadSafe<DeltaUpdateOp> {
   void Run(const base::DictionaryValue* command_args,
            const base::FilePath& input_dir,
            const base::FilePath& unpack_dir,
-           const scoped_refptr<CrxInstaller>& installer,
+           const scoped_refptr<ComponentInstaller>& installer,
            const ComponentUnpacker::Callback& callback,
            const scoped_refptr<base::SequencedTaskRunner>& task_runner);
 
@@ -60,7 +60,7 @@ class DeltaUpdateOp : public base::RefCountedThreadSafe<DeltaUpdateOp> {
   virtual ComponentUnpacker::Error DoParseArguments(
       const base::DictionaryValue* command_args,
       const base::FilePath& input_dir,
-      const scoped_refptr<CrxInstaller>& installer) = 0;
+      const scoped_refptr<ComponentInstaller>& installer) = 0;
 
   // Subclasses must override DoRun to actually perform the patching operation.
   // They must call the provided callback when they have completed their
@@ -92,7 +92,7 @@ class DeltaUpdateOpCopy : public DeltaUpdateOp {
   ComponentUnpacker::Error DoParseArguments(
       const base::DictionaryValue* command_args,
       const base::FilePath& input_dir,
-      const scoped_refptr<CrxInstaller>& installer) override;
+      const scoped_refptr<ComponentInstaller>& installer) override;
 
   void DoRun(const ComponentUnpacker::Callback& callback) override;
 
@@ -116,7 +116,7 @@ class DeltaUpdateOpCreate : public DeltaUpdateOp {
   ComponentUnpacker::Error DoParseArguments(
       const base::DictionaryValue* command_args,
       const base::FilePath& input_dir,
-      const scoped_refptr<CrxInstaller>& installer) override;
+      const scoped_refptr<ComponentInstaller>& installer) override;
 
   void DoRun(const ComponentUnpacker::Callback& callback) override;
 
@@ -160,7 +160,7 @@ class DeltaUpdateOpPatch : public DeltaUpdateOp {
   ComponentUnpacker::Error DoParseArguments(
       const base::DictionaryValue* command_args,
       const base::FilePath& input_dir,
-      const scoped_refptr<CrxInstaller>& installer) override;
+      const scoped_refptr<ComponentInstaller>& installer) override;
 
   void DoRun(const ComponentUnpacker::Callback& callback) override;
 
diff --git a/components/update_client/component_unpacker.cc b/components/update_client/component_unpacker.cc
index cabc4cb..efde910 100644
--- a/components/update_client/component_unpacker.cc
+++ b/components/update_client/component_unpacker.cc
@@ -102,7 +102,7 @@ ComponentUnpacker::ComponentUnpacker(
     const std::vector<uint8_t>& pk_hash,
     const base::FilePath& path,
     const std::string& fingerprint,
-    const scoped_refptr<CrxInstaller>& installer,
+    const scoped_refptr<ComponentInstaller>& installer,
     const scoped_refptr<OutOfProcessPatcher>& oop_patcher,
     const scoped_refptr<base::SequencedTaskRunner>& task_runner)
     : pk_hash_(pk_hash),
diff --git a/components/update_client/component_unpacker.h b/components/update_client/component_unpacker.h
index c1c6c9e..033fd33 100644
--- a/components/update_client/component_unpacker.h
+++ b/components/update_client/component_unpacker.h
@@ -19,7 +19,7 @@
 
 namespace update_client {
 
-class CrxInstaller;
+class ComponentInstaller;
 class ComponentPatcher;
 class OutOfProcessPatcher;
 
@@ -99,7 +99,7 @@ class ComponentUnpacker : public base::RefCountedThreadSafe<ComponentUnpacker> {
       const std::vector<uint8_t>& pk_hash,
       const base::FilePath& path,
       const std::string& fingerprint,
-      const scoped_refptr<CrxInstaller>& installer,
+      const scoped_refptr<ComponentInstaller>& installer,
       const scoped_refptr<OutOfProcessPatcher>& oop_patcher,
       const scoped_refptr<base::SequencedTaskRunner>& task_runner);
 
@@ -148,7 +148,7 @@ class ComponentUnpacker : public base::RefCountedThreadSafe<ComponentUnpacker> {
   bool is_delta_;
   std::string fingerprint_;
   scoped_refptr<ComponentPatcher> patcher_;
-  scoped_refptr<CrxInstaller> installer_;
+  scoped_refptr<ComponentInstaller> installer_;
   Callback callback_;
   scoped_refptr<OutOfProcessPatcher> oop_patcher_;
   Error error_;
diff --git a/components/update_client/configurator.h b/components/update_client/configurator.h
index c4c763f..b9a86fa 100644
--- a/components/update_client/configurator.h
+++ b/components/update_client/configurator.h
@@ -31,8 +31,10 @@ class OutOfProcessPatcher;
 // TODO(sorin): this class will be split soon in two. One class controls
 // the behavior of the update client, and the other class controls the
 // behavior of the component updater.
-class Configurator : public base::RefCountedThreadSafe<Configurator> {
+class Configurator {
  public:
+  virtual ~Configurator() {}
+
   // Delay in seconds from calling Start() to the first update check.
   virtual int InitialDelay() const = 0;
 
@@ -55,10 +57,6 @@ class Configurator : public base::RefCountedThreadSafe<Configurator> {
   // for the same component.
   virtual int OnDemandDelay() const = 0;
 
-  // The time delay in seconds between applying updates for different
-  // components.
-  virtual int UpdateDelay() const = 0;
-
   // The URLs for the update checks. The URLs are tried in order, the first one
   // that succeeds wins.
   virtual std::vector<GURL> UpdateUrl() const = 0;
@@ -114,11 +112,6 @@ class Configurator : public base::RefCountedThreadSafe<Configurator> {
   // initialized for use of COM objects.
   virtual scoped_refptr<base::SingleThreadTaskRunner>
   GetSingleThreadTaskRunner() const = 0;
-
- protected:
-  friend class base::RefCountedThreadSafe<Configurator>;
-
-  virtual ~Configurator() {}
 };
 
 }  // namespace update_client
diff --git a/components/update_client/crx_downloader.cc b/components/update_client/crx_downloader.cc
index 9bb7e18..ecbf301 100644
--- a/components/update_client/crx_downloader.cc
+++ b/components/update_client/crx_downloader.cc
@@ -29,22 +29,22 @@ CrxDownloader::DownloadMetrics::DownloadMetrics()
 
 // On Windows, the first downloader in the chain is a background downloader,
 // which uses the BITS service.
-scoped_ptr<CrxDownloader> CrxDownloader::Create(
+CrxDownloader* CrxDownloader::Create(
     bool is_background_download,
     net::URLRequestContextGetter* context_getter,
-    const scoped_refptr<base::SequencedTaskRunner>& url_fetcher_task_runner,
-    const scoped_refptr<base::SingleThreadTaskRunner>& background_task_runner) {
-  scoped_ptr<CrxDownloader> url_fetcher_downloader(scoped_ptr<CrxDownloader>(
+    scoped_refptr<base::SequencedTaskRunner> url_fetcher_task_runner,
+    scoped_refptr<base::SingleThreadTaskRunner> background_task_runner) {
+  scoped_ptr<CrxDownloader> url_fetcher_downloader(
       new UrlFetcherDownloader(scoped_ptr<CrxDownloader>().Pass(),
-                               context_getter, url_fetcher_task_runner)));
+                               context_getter, url_fetcher_task_runner));
 #if defined(OS_WIN)
   if (is_background_download) {
-    return scoped_ptr<CrxDownloader>(new BackgroundDownloader(
-        url_fetcher_downloader.Pass(), context_getter, background_task_runner));
+    return new BackgroundDownloader(url_fetcher_downloader.Pass(),
+                                    context_getter, background_task_runner);
   }
 #endif
 
-  return url_fetcher_downloader;
+  return url_fetcher_downloader.release();
 }
 
 CrxDownloader::CrxDownloader(scoped_ptr<CrxDownloader> successor)
diff --git a/components/update_client/crx_downloader.h b/components/update_client/crx_downloader.h
index 7d7720f..661b5c8 100644
--- a/components/update_client/crx_downloader.h
+++ b/components/update_client/crx_downloader.h
@@ -79,19 +79,13 @@ class CrxDownloader {
   // download. The callback interface can be extended if needed to provide
   // more visibility into how the download has been handled, including
   // specific error codes and download metrics.
-  using DownloadCallback = base::Callback<void(const Result& result)>;
+  typedef base::Callback<void(const Result& result)> DownloadCallback;
 
   // The callback may fire 0 or many times during a download. Since this
   // class implements a chain of responsibility, the callback can fire for
   // different urls and different downloaders. The number of actual downloaded
   // bytes is not guaranteed to monotonically increment over time.
-  using ProgressCallback = base::Callback<void(const Result& result)>;
-
-  using Factory = scoped_ptr<CrxDownloader>(*)(
-      bool,
-      net::URLRequestContextGetter*,
-      const scoped_refptr<base::SequencedTaskRunner>&,
-      const scoped_refptr<base::SingleThreadTaskRunner>&);
+  typedef base::Callback<void(const Result& result)> ProgressCallback;
 
   // Factory method to create an instance of this class and build the
   // chain of responsibility. |is_background_download| specifies that a
@@ -99,12 +93,11 @@ class CrxDownloader {
   // |url_fetcher_task_runner| should be an IO capable task runner able to
   // support UrlFetcherDownloader. |background_task_runner| should be an
   // IO capable thread able to support BackgroundDownloader.
-  static scoped_ptr<CrxDownloader> Create(
+  static CrxDownloader* Create(
       bool is_background_download,
       net::URLRequestContextGetter* context_getter,
-      const scoped_refptr<base::SequencedTaskRunner>& url_fetcher_task_runner,
-      const scoped_refptr<base::SingleThreadTaskRunner>&
-          background_task_runner);
+      scoped_refptr<base::SequencedTaskRunner> url_fetcher_task_runner,
+      scoped_refptr<base::SingleThreadTaskRunner> background_task_runner);
   virtual ~CrxDownloader();
 
   void set_progress_callback(const ProgressCallback& progress_callback);
diff --git a/components/update_client/crx_update_item.h b/components/update_client/crx_update_item.h
index f066ca2..09af62f 100644
--- a/components/update_client/crx_update_item.h
+++ b/components/update_client/crx_update_item.h
@@ -52,17 +52,13 @@ namespace update_client {
 //     |              error                            V           |
 //     +------------------------------------------ kUpdating ->----+ success
 //
-// TODO(sorin): this data structure will be further refactored once
-// the new update service is in place. For the time being, it remains as-is,
-// since it is used by the old component update service.
 struct CrxUpdateItem {
-  enum class State {
+  enum Status {
     kNew,
     kChecking,
     kCanUpdate,
     kDownloadingDiff,
     kDownloading,
-    kDownloaded,
     kUpdatingDiff,
     kUpdating,
     kUpdated,
@@ -73,7 +69,7 @@ struct CrxUpdateItem {
 
   // Call CrxUpdateService::ChangeItemState to change |status|. The function may
   // enforce conditions or notify observers of the change.
-  State state;
+  Status status;
 
   // True if the component was recently unregistered and will be uninstalled
   // soon (after the currently operation is finished, if there is one).
diff --git a/components/update_client/ping_manager.cc b/components/update_client/ping_manager.cc
index 24afde6..d3eb83c 100644
--- a/components/update_client/ping_manager.cc
+++ b/components/update_client/ping_manager.cc
@@ -81,13 +81,13 @@ std::string BuildDownloadCompleteEventElements(const CrxUpdateItem* item) {
 
 // Returns a string representing one ping event xml element for an update item.
 std::string BuildUpdateCompleteEventElement(const CrxUpdateItem* item) {
-  DCHECK(item->state == CrxUpdateItem::State::kNoUpdate ||
-         item->state == CrxUpdateItem::State::kUpdated);
+  DCHECK(item->status == CrxUpdateItem::kNoUpdate ||
+         item->status == CrxUpdateItem::kUpdated);
 
   using base::StringAppendF;
 
   std::string ping_event("<event eventtype=\"3\"");
-  const int event_result = item->state == CrxUpdateItem::State::kUpdated;
+  const int event_result = item->status == CrxUpdateItem::kUpdated;
   StringAppendF(&ping_event, " eventresult=\"%d\"", event_result);
   if (item->error_category)
     StringAppendF(&ping_event, " errorcat=\"%d\"", item->error_category);
diff --git a/components/update_client/ping_manager.h b/components/update_client/ping_manager.h
index 664142b..df2fa44 100644
--- a/components/update_client/ping_manager.h
+++ b/components/update_client/ping_manager.h
@@ -17,9 +17,9 @@ struct CrxUpdateItem;
 class PingManager {
  public:
   explicit PingManager(const Configurator& config);
-  virtual ~PingManager();
+  ~PingManager();
 
-  virtual void OnUpdateComplete(const CrxUpdateItem* item);
+  void OnUpdateComplete(const CrxUpdateItem* item);
 
  private:
   const Configurator& config_;
diff --git a/components/update_client/task.h b/components/update_client/task.h
deleted file mode 100644
index 51b6890..0000000
--- a/components/update_client/task.h
+++ /dev/null
@@ -1,30 +0,0 @@
-// Copyright 2015 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.
-
-#ifndef COMPONENTS_UPDATE_CLIENT_TASK_H_
-#define COMPONENTS_UPDATE_CLIENT_TASK_H_
-
-#include "base/callback.h"
-#include "base/memory/scoped_ptr.h"
-#include "components/update_client/update_client.h"
-
-namespace update_client {
-
-class Task;
-
-// Defines an abstraction for a unit of work done by the update client.
-// Each invocation of the update client API results in a task being created and
-// run. In most cases, a task corresponds to a set of CRXs, which are updated
-// together.
-class Task {
- public:
-  using Callback = base::Callback<void(Task* task, int error)>;
-  virtual ~Task() {}
-
-  virtual void Run(const Callback& callback) = 0;
-};
-
-}  // namespace update_client
-
-#endif  // COMPONENTS_UPDATE_CLIENT_TASK_H_
diff --git a/components/update_client/task_update.cc b/components/update_client/task_update.cc
deleted file mode 100644
index 2cbf001..0000000
--- a/components/update_client/task_update.cc
+++ /dev/null
@@ -1,46 +0,0 @@
-// Copyright 2015 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/task_update.h"
-
-#include "base/bind.h"
-#include "base/bind_helpers.h"
-#include "base/location.h"
-#include "base/single_thread_task_runner.h"
-#include "base/thread_task_runner_handle.h"
-#include "components/update_client/update_engine.h"
-
-namespace update_client {
-
-TaskUpdate::TaskUpdate(UpdateEngine* update_engine,
-                       const std::vector<std::string>& ids,
-                       const UpdateClient::CrxDataCallback& crx_data_callback)
-    : update_engine_(update_engine),
-      ids_(ids),
-      crx_data_callback_(crx_data_callback) {
-}
-
-TaskUpdate::~TaskUpdate() {
-  DCHECK(thread_checker_.CalledOnValidThread());
-}
-
-void TaskUpdate::Run(const Callback& callback) {
-  DCHECK(thread_checker_.CalledOnValidThread());
-
-  callback_ = callback;
-
-  if (ids_.empty())
-    RunComplete(-1);
-
-  update_engine_->Update(
-      ids_, crx_data_callback_,
-      base::Bind(&TaskUpdate::RunComplete, base::Unretained(this)));
-}
-
-void TaskUpdate::RunComplete(int error) {
-  DCHECK(thread_checker_.CalledOnValidThread());
-
-  callback_.Run(this, error);
-}
-
-}  // namespace update_client
diff --git a/components/update_client/task_update.h b/components/update_client/task_update.h
deleted file mode 100644
index 7a91c28..0000000
--- a/components/update_client/task_update.h
+++ /dev/null
@@ -1,52 +0,0 @@
-// Copyright 2015 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.
-
-#ifndef COMPONENTS_UPDATE_CLIENT_TASK_UPDATE_H_
-#define COMPONENTS_UPDATE_CLIENT_TASK_UPDATE_H_
-
-#include <queue>
-#include <string>
-#include <vector>
-
-#include "base/callback.h"
-#include "base/macros.h"
-#include "base/threading/thread_checker.h"
-#include "components/update_client/task.h"
-#include "components/update_client/update_client.h"
-
-namespace update_client {
-
-class UpdateEngine;
-
-// Defines a specialized task for updating a group of CRXs.
-class TaskUpdate : public Task {
- public:
-  TaskUpdate(UpdateEngine* update_engine,
-             const std::vector<std::string>& ids,
-             const UpdateClient::CrxDataCallback& crx_data_callback);
-  ~TaskUpdate() override;
-
-  void Run(const Callback& callback) override;
-
- private:
-  // Called when the Run function associated with this task has completed.
-  void RunComplete(int error);
-
-  base::ThreadChecker thread_checker_;
-
-  UpdateEngine* update_engine_;  // Not owned by this class.
-
-  const std::vector<std::string> ids_;
-  const UpdateClient::CrxDataCallback crx_data_callback_;
-
-  // Called to return the execution flow back to the caller of the
-  // Run function when this task has completed .
-  Callback callback_;
-
-  DISALLOW_COPY_AND_ASSIGN(TaskUpdate);
-};
-
-}  // namespace update_client
-
-#endif  // COMPONENTS_UPDATE_CLIENT_TASK_UPDATE_H_
diff --git a/components/update_client/test/DEPS b/components/update_client/test/DEPS
index d0c36c4..60dbcf4 100644
--- a/components/update_client/test/DEPS
+++ b/components/update_client/test/DEPS
@@ -1,5 +1,3 @@
 include_rules = [
   "+content",
-  "+courgette",
-  "+net",
 ]
diff --git a/components/update_client/test/crx_downloader_unittest.cc b/components/update_client/test/crx_downloader_unittest.cc
index 4b80f13..5b01b42 100644
--- a/components/update_client/test/crx_downloader_unittest.cc
+++ b/components/update_client/test/crx_downloader_unittest.cc
@@ -113,10 +113,10 @@ void CrxDownloaderTest::SetUp() {
   num_progress_calls_ = 0;
   download_progress_result_ = CrxDownloader::Result();
 
-  // Do not use the background downloader in these tests.
-  crx_downloader_.reset(CrxDownloader::Create(false, context_.get(),
-                                              base::MessageLoopProxy::current(),
-                                              NULL).release());
+  crx_downloader_.reset(CrxDownloader::Create(
+      false,  // Do not use the background downloader in these tests.
+      context_.get(), base::MessageLoopProxy::current(),
+      NULL));  // No |background_task_runner| because no background downloader.
   crx_downloader_->set_progress_callback(progress_callback_);
 
   get_interceptor_.reset(new GetInterceptor(base::MessageLoopProxy::current(),
diff --git a/components/update_client/test/ping_manager_unittest.cc b/components/update_client/test/ping_manager_unittest.cc
index 23308ac..95539f03 100644
--- a/components/update_client/test/ping_manager_unittest.cc
+++ b/components/update_client/test/ping_manager_unittest.cc
@@ -2,7 +2,6 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
@@ -30,25 +29,25 @@ class ComponentUpdaterPingManagerTest : public testing::Test {
   void TearDown() override;
 
  protected:
-  scoped_refptr<TestConfigurator> config_;
+  scoped_ptr<TestConfigurator> config_;
   scoped_ptr<PingManager> ping_manager_;
 
  private:
   base::MessageLoopForIO loop_;
 };
 
-ComponentUpdaterPingManagerTest::ComponentUpdaterPingManagerTest() {
+ComponentUpdaterPingManagerTest::ComponentUpdaterPingManagerTest()
+    : config_(new TestConfigurator(base::MessageLoopProxy::current(),
+                                   base::MessageLoopProxy::current())) {
 }
 
 void ComponentUpdaterPingManagerTest::SetUp() {
-  config_ = new TestConfigurator(base::MessageLoopProxy::current(),
-                                 base::MessageLoopProxy::current());
   ping_manager_.reset(new PingManager(*config_));
 }
 
 void ComponentUpdaterPingManagerTest::TearDown() {
   ping_manager_.reset();
-  config_ = nullptr;
+  config_.reset();
 }
 
 void ComponentUpdaterPingManagerTest::RunThreadsUntilIdle() {
@@ -66,7 +65,7 @@ TEST_F(ComponentUpdaterPingManagerTest, DISABLED_PingManagerTest) {
   // Test eventresult="1" is sent for successful updates.
   CrxUpdateItem item;
   item.id = "abc";
-  item.state = CrxUpdateItem::State::kUpdated;
+  item.status = CrxUpdateItem::kUpdated;
   item.previous_version = base::Version("1.0");
   item.next_version = base::Version("2.0");
 
@@ -84,7 +83,7 @@ TEST_F(ComponentUpdaterPingManagerTest, DISABLED_PingManagerTest) {
   // Test eventresult="0" is sent for failed updates.
   item = CrxUpdateItem();
   item.id = "abc";
-  item.state = CrxUpdateItem::State::kNoUpdate;
+  item.status = CrxUpdateItem::kNoUpdate;
   item.previous_version = base::Version("1.0");
   item.next_version = base::Version("2.0");
 
@@ -102,7 +101,7 @@ TEST_F(ComponentUpdaterPingManagerTest, DISABLED_PingManagerTest) {
   // Test the error values and the fingerprints.
   item = CrxUpdateItem();
   item.id = "abc";
-  item.state = CrxUpdateItem::State::kNoUpdate;
+  item.status = CrxUpdateItem::kNoUpdate;
   item.previous_version = base::Version("1.0");
   item.next_version = base::Version("2.0");
   item.previous_fp = "prev fp";
@@ -134,7 +133,7 @@ TEST_F(ComponentUpdaterPingManagerTest, DISABLED_PingManagerTest) {
   // Test the download metrics.
   item = CrxUpdateItem();
   item.id = "abc";
-  item.state = CrxUpdateItem::State::kUpdated;
+  item.status = CrxUpdateItem::kUpdated;
   item.previous_version = base::Version("1.0");
   item.next_version = base::Version("2.0");
 
diff --git a/components/update_client/test/request_sender_unittest.cc b/components/update_client/test/request_sender_unittest.cc
index 35d4487..f8ad042 100644
--- a/components/update_client/test/request_sender_unittest.cc
+++ b/components/update_client/test/request_sender_unittest.cc
@@ -4,7 +4,6 @@
 
 #include "base/compiler_specific.h"
 #include "base/macros.h"
-#include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
@@ -41,7 +40,7 @@ class RequestSenderTest : public testing::Test {
   void RunThreads();
   void RunThreadsUntilIdle();
 
-  scoped_refptr<TestConfigurator> config_;
+  scoped_ptr<TestConfigurator> config_;
   scoped_ptr<RequestSender> request_sender_;
   scoped_ptr<InterceptorFactory> interceptor_factory_;
 
@@ -67,8 +66,8 @@ RequestSenderTest::~RequestSenderTest() {
 }
 
 void RequestSenderTest::SetUp() {
-  config_ = new TestConfigurator(base::MessageLoopProxy::current(),
-                                 base::MessageLoopProxy::current());
+  config_.reset(new TestConfigurator(base::MessageLoopProxy::current(),
+                                     base::MessageLoopProxy::current()));
   interceptor_factory_.reset(
       new InterceptorFactory(base::MessageLoopProxy::current()));
   post_interceptor_1 =
@@ -89,7 +88,7 @@ void RequestSenderTest::TearDown() {
 
   interceptor_factory_.reset();
 
-  config_ = nullptr;
+  config_.reset();
 
   RunThreadsUntilIdle();
 }
diff --git a/components/update_client/test/test_configurator.cc b/components/update_client/test/test_configurator.cc
index 23eaeff..27aaf5f 100644
--- a/components/update_client/test/test_configurator.cc
+++ b/components/update_client/test/test_configurator.cc
@@ -68,10 +68,6 @@ int TestConfigurator::OnDemandDelay() const {
   return ondemand_time_;
 }
 
-int TestConfigurator::UpdateDelay() const {
-  return 1;
-}
-
 std::vector<GURL> TestConfigurator::UpdateUrl() const {
   return MakeDefaultUrls();
 }
diff --git a/components/update_client/test/test_configurator.h b/components/update_client/test/test_configurator.h
index 6c2ed0e..4943cca 100644
--- a/components/update_client/test/test_configurator.h
+++ b/components/update_client/test/test_configurator.h
@@ -55,6 +55,7 @@ class TestConfigurator : public Configurator {
   TestConfigurator(
       const scoped_refptr<base::SequencedTaskRunner>& worker_task_runner,
       const scoped_refptr<base::SingleThreadTaskRunner>& network_task_runner);
+  ~TestConfigurator() override;
 
   // Overrrides for Configurator.
   int InitialDelay() const override;
@@ -63,7 +64,6 @@ class TestConfigurator : public Configurator {
   int StepDelayMedium() override;
   int MinimumReCheckWait() const override;
   int OnDemandDelay() const override;
-  int UpdateDelay() const override;
   std::vector<GURL> UpdateUrl() const override;
   std::vector<GURL> PingUrl() const override;
   base::Version GetBrowserVersion() const override;
@@ -88,10 +88,6 @@ class TestConfigurator : public Configurator {
   void SetInitialDelay(int seconds);
 
  private:
-  friend class base::RefCountedThreadSafe<TestConfigurator>;
-
-  ~TestConfigurator() override;
-
   scoped_refptr<base::SequencedTaskRunner> worker_task_runner_;
   scoped_refptr<base::SingleThreadTaskRunner> network_task_runner_;
 
diff --git a/components/update_client/test/test_installer.h b/components/update_client/test/test_installer.h
index e15ae0a..a31c499 100644
--- a/components/update_client/test/test_installer.h
+++ b/components/update_client/test/test_installer.h
@@ -17,10 +17,9 @@ class DictionaryValue;
 
 namespace update_client {
 
-// TODO(sorin): consider reducing the number of the installer mocks.
 // A TestInstaller is an installer that does nothing for installation except
 // increment a counter.
-class TestInstaller : public CrxInstaller {
+class TestInstaller : public ComponentInstaller {
  public:
   TestInstaller();
 
diff --git a/components/update_client/test/update_checker_unittest.cc b/components/update_client/test/update_checker_unittest.cc
index ce6922a..20d3e79 100644
--- a/components/update_client/test/update_checker_unittest.cc
+++ b/components/update_client/test/update_checker_unittest.cc
@@ -60,7 +60,7 @@ class UpdateCheckerTest : public testing::Test {
 
   CrxUpdateItem BuildCrxUpdateItem();
 
-  scoped_refptr<TestConfigurator> config_;
+  scoped_ptr<TestConfigurator> config_;
 
   scoped_ptr<UpdateChecker> update_checker_;
 
@@ -86,8 +86,8 @@ UpdateCheckerTest::~UpdateCheckerTest() {
 }
 
 void UpdateCheckerTest::SetUp() {
-  config_ = new TestConfigurator(base::MessageLoopProxy::current(),
-                                 base::MessageLoopProxy::current());
+  config_.reset(new TestConfigurator(base::MessageLoopProxy::current(),
+                                     base::MessageLoopProxy::current()));
   interceptor_factory_.reset(
       new InterceptorFactory(base::MessageLoopProxy::current()));
   post_interceptor_ = interceptor_factory_->CreateInterceptor();
@@ -106,7 +106,7 @@ void UpdateCheckerTest::TearDown() {
   post_interceptor_ = NULL;
   interceptor_factory_.reset();
 
-  config_ = nullptr;
+  config_.reset();
 
   // The PostInterceptor requires the message loop to run to destruct correctly.
   // TODO(sorin): This is fragile and should be fixed.
@@ -155,7 +155,7 @@ CrxUpdateItem UpdateCheckerTest::BuildCrxUpdateItem() {
   crx_component.fingerprint = "fp1";
 
   CrxUpdateItem crx_update_item;
-  crx_update_item.state = CrxUpdateItem::State::kNew;
+  crx_update_item.status = CrxUpdateItem::kNew;
   crx_update_item.id = "jebgalgnebhfojomionfpkfelancnnkf";
   crx_update_item.component = crx_component;
 
diff --git a/components/update_client/test/update_client_unittest.cc b/components/update_client/test/update_client_unittest.cc
deleted file mode 100644
index dbff673..0000000
--- a/components/update_client/test/update_client_unittest.cc
+++ /dev/null
@@ -1,1417 +0,0 @@
-// Copyright 2015 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 "base/bind.h"
-#include "base/bind_helpers.h"
-#include "base/files/file_path.h"
-#include "base/files/file_util.h"
-#include "base/location.h"
-#include "base/memory/ref_counted.h"
-#include "base/memory/scoped_ptr.h"
-#include "base/message_loop/message_loop.h"
-#include "base/path_service.h"
-#include "base/run_loop.h"
-#include "base/thread_task_runner_handle.h"
-#include "base/values.h"
-#include "base/version.h"
-#include "components/update_client/crx_update_item.h"
-#include "components/update_client/ping_manager.h"
-#include "components/update_client/test/test_configurator.h"
-#include "components/update_client/test/test_installer.h"
-#include "components/update_client/update_checker.h"
-#include "components/update_client/update_client_internal.h"
-#include "content/public/browser/browser_thread.h"
-#include "content/public/test/test_browser_thread_bundle.h"
-#include "testing/gmock/include/gmock/gmock.h"
-#include "testing/gtest/include/gtest/gtest.h"
-#include "url/gurl.h"
-
-namespace update_client {
-
-namespace {
-
-using base::FilePath;
-
-// Makes a copy of the file specified by |from_path| in a temporary directory
-// and returns the path of the copy. Returns true if successful. Cleans up if
-// there was an error creating the copy.
-bool MakeTestFile(const FilePath& from_path, FilePath* to_path) {
-  FilePath path;
-  bool result = CreateTemporaryFile(&path);
-  if (!result)
-    return false;
-
-  result = CopyFile(from_path, path);
-  if (!result) {
-    DeleteFile(path, false);
-    return result;
-  }
-
-  *to_path = path;
-  return true;
-}
-
-using Events = UpdateClient::Observer::Events;
-
-class MockObserver : public UpdateClient::Observer {
- public:
-  MOCK_METHOD2(OnEvent, void(Events event, const std::string&));
-};
-
-class FakePingManagerImpl : public PingManager {
- public:
-  explicit FakePingManagerImpl(const Configurator& config);
-  ~FakePingManagerImpl() override;
-
-  void OnUpdateComplete(const CrxUpdateItem* item) override;
-
-  const std::vector<CrxUpdateItem>& items() const;
-
- private:
-  std::vector<CrxUpdateItem> items_;
-  DISALLOW_COPY_AND_ASSIGN(FakePingManagerImpl);
-};
-
-FakePingManagerImpl::FakePingManagerImpl(const Configurator& config)
-    : PingManager(config) {
-}
-
-FakePingManagerImpl::~FakePingManagerImpl() {
-}
-
-void FakePingManagerImpl::OnUpdateComplete(const CrxUpdateItem* item) {
-  items_.push_back(*item);
-}
-
-const std::vector<CrxUpdateItem>& FakePingManagerImpl::items() const {
-  return items_;
-}
-
-}  // namespace
-
-using ::testing::_;
-using ::testing::AnyNumber;
-using ::testing::DoAll;
-using ::testing::InSequence;
-using ::testing::Invoke;
-using ::testing::Mock;
-using ::testing::Return;
-
-using content::BrowserThread;
-
-using std::string;
-
-class UpdateClientTest : public testing::Test {
- public:
-  UpdateClientTest();
-  ~UpdateClientTest() override;
-
-  void SetUp() override;
-  void TearDown() override;
-
- protected:
-  void RunThreads();
-
-  // Returns the full path to a test file.
-  static base::FilePath TestFilePath(const char* file);
-
-  content::TestBrowserThreadBundle thread_bundle_;
-
-  base::RunLoop runloop_;
-  base::Closure quit_closure_;
-
-  scoped_refptr<update_client::TestConfigurator> config_;
-
- private:
-  DISALLOW_COPY_AND_ASSIGN(UpdateClientTest);
-};
-
-UpdateClientTest::UpdateClientTest()
-    : thread_bundle_(content::TestBrowserThreadBundle::IO_MAINLOOP),
-      config_(new TestConfigurator(
-          BrowserThread::GetBlockingPool()
-              ->GetSequencedTaskRunnerWithShutdownBehavior(
-                  BrowserThread::GetBlockingPool()->GetSequenceToken(),
-                  base::SequencedWorkerPool::SKIP_ON_SHUTDOWN),
-          BrowserThread::GetMessageLoopProxyForThread(BrowserThread::IO))) {
-}
-
-UpdateClientTest::~UpdateClientTest() {
-}
-
-void UpdateClientTest::SetUp() {
-  quit_closure_ = runloop_.QuitClosure();
-}
-
-void UpdateClientTest::TearDown() {
-}
-
-void UpdateClientTest::RunThreads() {
-  runloop_.Run();
-}
-
-base::FilePath UpdateClientTest::TestFilePath(const char* file) {
-  base::FilePath path;
-  PathService::Get(base::DIR_SOURCE_ROOT, &path);
-  return path.AppendASCII("components")
-      .AppendASCII("test")
-      .AppendASCII("data")
-      .AppendASCII("update_client")
-      .AppendASCII(file);
-}
-
-// Tests the scenario where one update check is done for one CRX. The CRX
-// has no update.
-TEST_F(UpdateClientTest, OneCrxNoUpdate) {
-  class DataCallbackFake {
-   public:
-    static void Callback(const std::vector<std::string>& ids,
-                         std::vector<CrxComponent>* components) {
-      CrxComponent crx;
-      crx.name = "test_jebg";
-      crx.pk_hash.assign(jebg_hash, jebg_hash + arraysize(jebg_hash));
-      crx.version = Version("0.9");
-      crx.installer = new TestInstaller;
-      components->push_back(crx);
-    }
-  };
-
-  class CompletionCallbackFake {
-   public:
-    static void Callback(const base::Closure& quit_closure, int error) {
-      EXPECT_EQ(0, error);
-      quit_closure.Run();
-    }
-  };
-
-  class FakeUpdateChecker : public UpdateChecker {
-   public:
-    static scoped_ptr<UpdateChecker> Create(const Configurator& config) {
-      return scoped_ptr<UpdateChecker>(new FakeUpdateChecker());
-    }
-
-    bool CheckForUpdates(
-        const std::vector<CrxUpdateItem*>& items_to_check,
-        const std::string& additional_attributes,
-        const UpdateCheckCallback& update_check_callback) override {
-      base::ThreadTaskRunnerHandle::Get()->PostTask(
-          FROM_HERE, base::Bind(update_check_callback, GURL(), 0, "",
-                                UpdateResponse::Results()));
-      return true;
-    }
-  };
-
-  class FakeCrxDownloader : public CrxDownloader {
-   public:
-    static scoped_ptr<CrxDownloader> Create(
-        bool is_background_download,
-        net::URLRequestContextGetter* context_getter,
-        const scoped_refptr<base::SequencedTaskRunner>& url_fetcher_task_runner,
-        const scoped_refptr<base::SingleThreadTaskRunner>&
-            background_task_runner) {
-      return scoped_ptr<CrxDownloader>(new FakeCrxDownloader());
-    }
-
-   private:
-    FakeCrxDownloader() : CrxDownloader(scoped_ptr<CrxDownloader>().Pass()) {}
-    ~FakeCrxDownloader() override {}
-
-    void DoStartDownload(const GURL& url) override { EXPECT_TRUE(false); }
-  };
-
-  class FakePingManager : public FakePingManagerImpl {
-   public:
-    explicit FakePingManager(const Configurator& config)
-        : FakePingManagerImpl(config) {}
-    ~FakePingManager() override { EXPECT_TRUE(items().empty()); }
-  };
-
-  scoped_ptr<PingManager> ping_manager(new FakePingManager(*config_));
-  scoped_ptr<UpdateClient> update_client(new UpdateClientImpl(
-      config_, ping_manager.Pass(), &FakeUpdateChecker::Create,
-      &FakeCrxDownloader::Create));
-
-  MockObserver observer;
-  InSequence seq;
-  EXPECT_CALL(observer, OnEvent(Events::COMPONENT_CHECKING_FOR_UPDATES,
-                                "jebgalgnebhfojomionfpkfelancnnkf")).Times(1);
-  EXPECT_CALL(observer, OnEvent(Events::COMPONENT_NOT_UPDATED,
-                                "jebgalgnebhfojomionfpkfelancnnkf")).Times(1);
-
-  update_client->AddObserver(&observer);
-
-  std::vector<std::string> ids;
-  ids.push_back(std::string("jebgalgnebhfojomionfpkfelancnnkf"));
-
-  update_client->Update(
-      ids, base::Bind(&DataCallbackFake::Callback),
-      base::Bind(&CompletionCallbackFake::Callback, quit_closure_));
-
-  RunThreads();
-
-  update_client->RemoveObserver(&observer);
-}
-
-// Tests the scenario where two CRXs are checked for updates. On CRX has
-// an update, the other CRX does not.
-TEST_F(UpdateClientTest, TwoCrxUpdateNoUpdate) {
-  class DataCallbackFake {
-   public:
-    static void Callback(const std::vector<std::string>& ids,
-                         std::vector<CrxComponent>* components) {
-      CrxComponent crx1;
-      crx1.name = "test_jebg";
-      crx1.pk_hash.assign(jebg_hash, jebg_hash + arraysize(jebg_hash));
-      crx1.version = Version("0.9");
-      crx1.installer = new TestInstaller;
-
-      CrxComponent crx2;
-      crx2.name = "test_abag";
-      crx2.pk_hash.assign(abag_hash, abag_hash + arraysize(abag_hash));
-      crx2.version = Version("2.2");
-      crx2.installer = new TestInstaller;
-
-      components->push_back(crx1);
-      components->push_back(crx2);
-    }
-  };
-
-  class CompletionCallbackFake {
-   public:
-    static void Callback(const base::Closure& quit_closure, int error) {
-      EXPECT_EQ(0, error);
-      quit_closure.Run();
-    }
-  };
-
-  class FakeUpdateChecker : public UpdateChecker {
-   public:
-    static scoped_ptr<UpdateChecker> Create(const Configurator& config) {
-      return scoped_ptr<UpdateChecker>(new FakeUpdateChecker());
-    }
-
-    bool CheckForUpdates(
-        const std::vector<CrxUpdateItem*>& items_to_check,
-        const std::string& additional_attributes,
-        const UpdateCheckCallback& update_check_callback) override {
-      /*
-      Fake the following response:
-
-      <?xml version='1.0' encoding='UTF-8'?>
-      <response protocol='3.0'>
-        <app appid='jebgalgnebhfojomionfpkfelancnnkf'>
-          <updatecheck status='ok'>
-            <urls>
-              <url codebase='http://localhost/download/'/>
-            </urls>
-            <manifest version='1.0' prodversionmin='11.0.1.0'>
-              <packages>
-                <package name='jebgalgnebhfojomionfpkfelancnnkf.crx'/>
-              </packages>
-            </manifest>
-          </updatecheck>
-        </app>
-      </response>
-      */
-      UpdateResponse::Result::Manifest::Package package;
-      package.name = "jebgalgnebhfojomionfpkfelancnnkf.crx";
-
-      UpdateResponse::Result result;
-      result.extension_id = "jebgalgnebhfojomionfpkfelancnnkf";
-      result.crx_urls.push_back(GURL("http://localhost/download/"));
-      result.manifest.version = "1.0";
-      result.manifest.browser_min_version = "11.0.1.0";
-      result.manifest.packages.push_back(package);
-
-      UpdateResponse::Results results;
-      results.list.push_back(result);
-
-      base::ThreadTaskRunnerHandle::Get()->PostTask(
-          FROM_HERE, base::Bind(update_check_callback, GURL(), 0, "", results));
-      return true;
-    }
-  };
-
-  class FakeCrxDownloader : public CrxDownloader {
-   public:
-    static scoped_ptr<CrxDownloader> Create(
-        bool is_background_download,
-        net::URLRequestContextGetter* context_getter,
-        const scoped_refptr<base::SequencedTaskRunner>& url_fetcher_task_runner,
-        const scoped_refptr<base::SingleThreadTaskRunner>&
-            background_task_runner) {
-      return scoped_ptr<CrxDownloader>(new FakeCrxDownloader());
-    }
-
-   private:
-    FakeCrxDownloader() : CrxDownloader(scoped_ptr<CrxDownloader>().Pass()) {}
-    ~FakeCrxDownloader() override {}
-
-    void DoStartDownload(const GURL& url) override {
-      DownloadMetrics download_metrics;
-      download_metrics.url = url;
-      download_metrics.downloader = DownloadMetrics::kNone;
-      download_metrics.error = 0;
-      download_metrics.downloaded_bytes = 1843;
-      download_metrics.total_bytes = 1843;
-      download_metrics.download_time_ms = 1000;
-
-      FilePath path;
-      EXPECT_TRUE(MakeTestFile(
-          TestFilePath("jebgalgnebhfojomionfpkfelancnnkf.crx"), &path));
-
-      Result result;
-      result.error = 0;
-      result.response = path;
-      result.downloaded_bytes = 1843;
-      result.total_bytes = 1843;
-
-      base::ThreadTaskRunnerHandle::Get()->PostTask(
-          FROM_HERE, base::Bind(&FakeCrxDownloader::OnDownloadProgress,
-                                base::Unretained(this), result));
-
-      base::ThreadTaskRunnerHandle::Get()->PostTask(
-          FROM_HERE,
-          base::Bind(&FakeCrxDownloader::OnDownloadComplete,
-                     base::Unretained(this), true, result, download_metrics));
-    }
-  };
-
-  class FakePingManager : public FakePingManagerImpl {
-   public:
-    explicit FakePingManager(const Configurator& config)
-        : FakePingManagerImpl(config) {}
-    ~FakePingManager() override {
-      const auto& ping_items = items();
-      EXPECT_EQ(1U, ping_items.size());
-      EXPECT_EQ("jebgalgnebhfojomionfpkfelancnnkf", ping_items[0].id);
-      EXPECT_TRUE(base::Version("0.9").Equals(ping_items[0].previous_version));
-      EXPECT_TRUE(base::Version("1.0").Equals(ping_items[0].next_version));
-      EXPECT_EQ(0, ping_items[0].error_category);
-      EXPECT_EQ(0, ping_items[0].error_code);
-    }
-  };
-
-  scoped_ptr<PingManager> ping_manager(new FakePingManager(*config_));
-  scoped_ptr<UpdateClient> update_client(new UpdateClientImpl(
-      config_, ping_manager.Pass(), &FakeUpdateChecker::Create,
-      &FakeCrxDownloader::Create));
-
-  MockObserver observer;
-  {
-    InSequence seq;
-    EXPECT_CALL(observer, OnEvent(Events::COMPONENT_CHECKING_FOR_UPDATES,
-                                  "jebgalgnebhfojomionfpkfelancnnkf")).Times(1);
-    EXPECT_CALL(observer, OnEvent(Events::COMPONENT_UPDATE_FOUND,
-                                  "jebgalgnebhfojomionfpkfelancnnkf")).Times(1);
-    EXPECT_CALL(observer, OnEvent(Events::COMPONENT_UPDATE_DOWNLOADING,
-                                  "jebgalgnebhfojomionfpkfelancnnkf")).Times(1);
-    EXPECT_CALL(observer, OnEvent(Events::COMPONENT_UPDATE_READY,
-                                  "jebgalgnebhfojomionfpkfelancnnkf")).Times(1);
-    EXPECT_CALL(observer, OnEvent(Events::COMPONENT_UPDATED,
-                                  "jebgalgnebhfojomionfpkfelancnnkf")).Times(1);
-  }
-  {
-    InSequence seq;
-    EXPECT_CALL(observer, OnEvent(Events::COMPONENT_CHECKING_FOR_UPDATES,
-                                  "abagagagagagagagagagagagagagagag")).Times(1);
-    EXPECT_CALL(observer, OnEvent(Events::COMPONENT_NOT_UPDATED,
-                                  "abagagagagagagagagagagagagagagag")).Times(1);
-  }
-
-  update_client->AddObserver(&observer);
-
-  std::vector<std::string> ids;
-  ids.push_back(std::string("jebgalgnebhfojomionfpkfelancnnkf"));
-  ids.push_back(std::string("abagagagagagagagagagagagagagagag"));
-
-  update_client->Update(
-      ids, base::Bind(&DataCallbackFake::Callback),
-      base::Bind(&CompletionCallbackFake::Callback, quit_closure_));
-
-  RunThreads();
-
-  update_client->RemoveObserver(&observer);
-}
-
-// Tests the update check for two CRXs scenario. Both CRXs have updates.
-TEST_F(UpdateClientTest, TwoCrxUpdate) {
-  class DataCallbackFake {
-   public:
-    static void Callback(const std::vector<std::string>& ids,
-                         std::vector<CrxComponent>* components) {
-      CrxComponent crx1;
-      crx1.name = "test_jebg";
-      crx1.pk_hash.assign(jebg_hash, jebg_hash + arraysize(jebg_hash));
-      crx1.version = Version("0.9");
-      crx1.installer = new TestInstaller;
-
-      CrxComponent crx2;
-      crx2.name = "test_ihfo";
-      crx2.pk_hash.assign(ihfo_hash, ihfo_hash + arraysize(ihfo_hash));
-      crx2.version = Version("0.8");
-      crx2.installer = new TestInstaller;
-
-      components->push_back(crx1);
-      components->push_back(crx2);
-    }
-  };
-
-  class CompletionCallbackFake {
-   public:
-    static void Callback(const base::Closure& quit_closure, int error) {
-      EXPECT_EQ(0, error);
-      quit_closure.Run();
-    }
-  };
-
-  class FakeUpdateChecker : public UpdateChecker {
-   public:
-    static scoped_ptr<UpdateChecker> Create(const Configurator& config) {
-      return scoped_ptr<UpdateChecker>(new FakeUpdateChecker());
-    }
-
-    bool CheckForUpdates(
-        const std::vector<CrxUpdateItem*>& items_to_check,
-        const std::string& additional_attributes,
-        const UpdateCheckCallback& update_check_callback) override {
-      /*
-      Fake the following response:
-
-      <?xml version='1.0' encoding='UTF-8'?>
-      <response protocol='3.0'>
-        <app appid='jebgalgnebhfojomionfpkfelancnnkf'>
-          <updatecheck status='ok'>
-            <urls>
-              <url codebase='http://localhost/download/'/>
-            </urls>
-            <manifest version='1.0' prodversionmin='11.0.1.0'>
-              <packages>
-                <package name='jebgalgnebhfojomionfpkfelancnnkf.crx'/>
-              </packages>
-            </manifest>
-          </updatecheck>
-        </app>
-        <app appid='ihfokbkgjpifnbbojhneepfflplebdkc'>
-          <updatecheck status='ok'>
-            <urls>
-              <url codebase='http://localhost/download/'/>
-            </urls>
-            <manifest version='1.0' prodversionmin='11.0.1.0'>
-              <packages>
-                <package name='ihfokbkgjpifnbbojhneepfflplebdkc_1.crx'/>
-              </packages>
-            </manifest>
-          </updatecheck>
-        </app>
-      </response>
-      */
-      UpdateResponse::Result::Manifest::Package package1;
-      package1.name = "jebgalgnebhfojomionfpkfelancnnkf.crx";
-
-      UpdateResponse::Result result1;
-      result1.extension_id = "jebgalgnebhfojomionfpkfelancnnkf";
-      result1.crx_urls.push_back(GURL("http://localhost/download/"));
-      result1.manifest.version = "1.0";
-      result1.manifest.browser_min_version = "11.0.1.0";
-      result1.manifest.packages.push_back(package1);
-
-      UpdateResponse::Result::Manifest::Package package2;
-      package2.name = "ihfokbkgjpifnbbojhneepfflplebdkc_1.crx";
-
-      UpdateResponse::Result result2;
-      result2.extension_id = "ihfokbkgjpifnbbojhneepfflplebdkc";
-      result2.crx_urls.push_back(GURL("http://localhost/download/"));
-      result2.manifest.version = "1.0";
-      result2.manifest.browser_min_version = "11.0.1.0";
-      result2.manifest.packages.push_back(package2);
-
-      UpdateResponse::Results results;
-      results.list.push_back(result1);
-      results.list.push_back(result2);
-
-      base::ThreadTaskRunnerHandle::Get()->PostTask(
-          FROM_HERE, base::Bind(update_check_callback, GURL(), 0, "", results));
-      return true;
-    }
-  };
-
-  class FakeCrxDownloader : public CrxDownloader {
-   public:
-    static scoped_ptr<CrxDownloader> Create(
-        bool is_background_download,
-        net::URLRequestContextGetter* context_getter,
-        const scoped_refptr<base::SequencedTaskRunner>& url_fetcher_task_runner,
-        const scoped_refptr<base::SingleThreadTaskRunner>&
-            background_task_runner) {
-      return scoped_ptr<CrxDownloader>(new FakeCrxDownloader());
-    }
-
-   private:
-    FakeCrxDownloader() : CrxDownloader(scoped_ptr<CrxDownloader>().Pass()) {}
-    ~FakeCrxDownloader() override {}
-
-    void DoStartDownload(const GURL& url) override {
-      DownloadMetrics download_metrics;
-      FilePath path;
-      Result result;
-      if (url.path() == "/download/jebgalgnebhfojomionfpkfelancnnkf.crx") {
-        download_metrics.url = url;
-        download_metrics.downloader = DownloadMetrics::kNone;
-        download_metrics.error = 0;
-        download_metrics.downloaded_bytes = 1843;
-        download_metrics.total_bytes = 1843;
-        download_metrics.download_time_ms = 1000;
-
-        EXPECT_TRUE(MakeTestFile(
-            TestFilePath("jebgalgnebhfojomionfpkfelancnnkf.crx"), &path));
-
-        result.error = 0;
-        result.response = path;
-        result.downloaded_bytes = 1843;
-        result.total_bytes = 1843;
-      } else if (url.path() ==
-                 "/download/ihfokbkgjpifnbbojhneepfflplebdkc_1.crx") {
-        download_metrics.url = url;
-        download_metrics.downloader = DownloadMetrics::kNone;
-        download_metrics.error = 0;
-        download_metrics.downloaded_bytes = 53638;
-        download_metrics.total_bytes = 53638;
-        download_metrics.download_time_ms = 2000;
-
-        EXPECT_TRUE(MakeTestFile(
-            TestFilePath("ihfokbkgjpifnbbojhneepfflplebdkc_1.crx"), &path));
-
-        result.error = 0;
-        result.response = path;
-        result.downloaded_bytes = 53638;
-        result.total_bytes = 53638;
-      } else {
-        NOTREACHED();
-      }
-
-      base::ThreadTaskRunnerHandle::Get()->PostTask(
-          FROM_HERE, base::Bind(&FakeCrxDownloader::OnDownloadProgress,
-                                base::Unretained(this), result));
-
-      base::ThreadTaskRunnerHandle::Get()->PostTask(
-          FROM_HERE,
-          base::Bind(&FakeCrxDownloader::OnDownloadComplete,
-                     base::Unretained(this), true, result, download_metrics));
-    }
-  };
-
-  class FakePingManager : public FakePingManagerImpl {
-   public:
-    explicit FakePingManager(const Configurator& config)
-        : FakePingManagerImpl(config) {}
-    ~FakePingManager() override {
-      const auto& ping_items = items();
-      EXPECT_EQ(2U, ping_items.size());
-      EXPECT_EQ("jebgalgnebhfojomionfpkfelancnnkf", ping_items[0].id);
-      EXPECT_TRUE(base::Version("0.9").Equals(ping_items[0].previous_version));
-      EXPECT_TRUE(base::Version("1.0").Equals(ping_items[0].next_version));
-      EXPECT_EQ(0, ping_items[0].error_category);
-      EXPECT_EQ(0, ping_items[0].error_code);
-      EXPECT_EQ("ihfokbkgjpifnbbojhneepfflplebdkc", ping_items[1].id);
-      EXPECT_TRUE(base::Version("0.8").Equals(ping_items[1].previous_version));
-      EXPECT_TRUE(base::Version("1.0").Equals(ping_items[1].next_version));
-      EXPECT_EQ(0, ping_items[1].error_category);
-      EXPECT_EQ(0, ping_items[1].error_code);
-    }
-  };
-
-  scoped_ptr<FakePingManager> ping_manager(new FakePingManager(*config_));
-  scoped_ptr<UpdateClient> update_client(new UpdateClientImpl(
-      config_, ping_manager.Pass(), &FakeUpdateChecker::Create,
-      &FakeCrxDownloader::Create));
-
-  MockObserver observer;
-  {
-    InSequence seq;
-    EXPECT_CALL(observer, OnEvent(Events::COMPONENT_CHECKING_FOR_UPDATES,
-                                  "jebgalgnebhfojomionfpkfelancnnkf")).Times(1);
-    EXPECT_CALL(observer, OnEvent(Events::COMPONENT_UPDATE_FOUND,
-                                  "jebgalgnebhfojomionfpkfelancnnkf")).Times(1);
-    EXPECT_CALL(observer, OnEvent(Events::COMPONENT_UPDATE_DOWNLOADING,
-                                  "jebgalgnebhfojomionfpkfelancnnkf")).Times(1);
-    EXPECT_CALL(observer, OnEvent(Events::COMPONENT_UPDATE_READY,
-                                  "jebgalgnebhfojomionfpkfelancnnkf")).Times(1);
-    EXPECT_CALL(observer, OnEvent(Events::COMPONENT_UPDATED,
-                                  "jebgalgnebhfojomionfpkfelancnnkf")).Times(1);
-  }
-  {
-    InSequence seq;
-    EXPECT_CALL(observer, OnEvent(Events::COMPONENT_CHECKING_FOR_UPDATES,
-                                  "ihfokbkgjpifnbbojhneepfflplebdkc")).Times(1);
-    EXPECT_CALL(observer, OnEvent(Events::COMPONENT_UPDATE_FOUND,
-                                  "ihfokbkgjpifnbbojhneepfflplebdkc")).Times(1);
-    EXPECT_CALL(observer, OnEvent(Events::COMPONENT_WAIT,
-                                  "ihfokbkgjpifnbbojhneepfflplebdkc")).Times(1);
-    EXPECT_CALL(observer, OnEvent(Events::COMPONENT_UPDATE_DOWNLOADING,
-                                  "ihfokbkgjpifnbbojhneepfflplebdkc")).Times(1);
-    EXPECT_CALL(observer, OnEvent(Events::COMPONENT_UPDATE_READY,
-                                  "ihfokbkgjpifnbbojhneepfflplebdkc")).Times(1);
-    EXPECT_CALL(observer, OnEvent(Events::COMPONENT_UPDATED,
-                                  "ihfokbkgjpifnbbojhneepfflplebdkc")).Times(1);
-  }
-
-  update_client->AddObserver(&observer);
-
-  std::vector<std::string> ids;
-  ids.push_back(std::string("jebgalgnebhfojomionfpkfelancnnkf"));
-  ids.push_back(std::string("ihfokbkgjpifnbbojhneepfflplebdkc"));
-
-  update_client->Update(
-      ids, base::Bind(&DataCallbackFake::Callback),
-      base::Bind(&CompletionCallbackFake::Callback, quit_closure_));
-
-  RunThreads();
-
-  update_client->RemoveObserver(&observer);
-}
-
-// Tests the differential update scenario for one CRX.
-TEST_F(UpdateClientTest, OneCrxDiffUpdate) {
-  class DataCallbackFake {
-   public:
-    static void Callback(const std::vector<std::string>& ids,
-                         std::vector<CrxComponent>* components) {
-      static int num_calls = 0;
-
-      // Must use the same stateful installer object.
-      static scoped_refptr<CrxInstaller> installer(
-          new VersionedTestInstaller());
-
-      ++num_calls;
-
-      CrxComponent crx;
-      crx.name = "test_ihfo";
-      crx.pk_hash.assign(ihfo_hash, ihfo_hash + arraysize(ihfo_hash));
-      crx.installer = installer;
-      if (num_calls == 1) {
-        crx.version = Version("0.8");
-      } else if (num_calls == 2) {
-        crx.version = Version("1.0");
-      } else {
-        NOTREACHED();
-      }
-
-      components->push_back(crx);
-    }
-  };
-
-  class CompletionCallbackFake {
-   public:
-    static void Callback(const base::Closure& quit_closure, int error) {
-      EXPECT_EQ(0, error);
-      quit_closure.Run();
-    }
-  };
-
-  class FakeUpdateChecker : public UpdateChecker {
-   public:
-    static scoped_ptr<UpdateChecker> Create(const Configurator& config) {
-      return scoped_ptr<UpdateChecker>(new FakeUpdateChecker());
-    }
-
-    bool CheckForUpdates(
-        const std::vector<CrxUpdateItem*>& items_to_check,
-        const std::string& additional_attributes,
-        const UpdateCheckCallback& update_check_callback) override {
-      static int num_call = 0;
-      ++num_call;
-
-      UpdateResponse::Results results;
-
-      if (num_call == 1) {
-        /*
-        Fake the following response:
-        <?xml version='1.0' encoding='UTF-8'?>
-        <response protocol='3.0'>
-          <app appid='ihfokbkgjpifnbbojhneepfflplebdkc'>
-            <updatecheck status='ok'>
-              <urls>
-                <url codebase='http://localhost/download/'/>
-              </urls>
-              <manifest version='1.0' prodversionmin='11.0.1.0'>
-                <packages>
-                  <package name='ihfokbkgjpifnbbojhneepfflplebdkc_1.crx'/>
-                </packages>
-              </manifest>
-            </updatecheck>
-          </app>
-        </response>
-        */
-        UpdateResponse::Result::Manifest::Package package;
-        package.name = "ihfokbkgjpifnbbojhneepfflplebdkc_1.crx";
-        package.fingerprint = "1";
-        UpdateResponse::Result result;
-        result.extension_id = "ihfokbkgjpifnbbojhneepfflplebdkc";
-        result.crx_urls.push_back(GURL("http://localhost/download/"));
-        result.manifest.version = "1.0";
-        result.manifest.browser_min_version = "11.0.1.0";
-        result.manifest.packages.push_back(package);
-        results.list.push_back(result);
-      } else if (num_call == 2) {
-        /*
-        Fake the following response:
-        <?xml version='1.0' encoding='UTF-8'?>
-        <response protocol='3.0'>
-          <app appid='ihfokbkgjpifnbbojhneepfflplebdkc'>
-            <updatecheck status='ok'>
-              <urls>
-                <url codebase='http://localhost/download/'/>
-                <url codebasediff='http://localhost/download/'/>
-              </urls>
-              <manifest version='2.0' prodversionmin='11.0.1.0'>
-                <packages>
-                  <package name='ihfokbkgjpifnbbojhneepfflplebdkc_2.crx'
-                           namediff='ihfokbkgjpifnbbojhneepfflplebdkc_1to2.crx'
-                           fp='22'/>
-                </packages>
-              </manifest>
-            </updatecheck>
-          </app>
-        </response>
-        */
-        UpdateResponse::Result::Manifest::Package package;
-        package.name = "ihfokbkgjpifnbbojhneepfflplebdkc_2.crx";
-        package.namediff = "ihfokbkgjpifnbbojhneepfflplebdkc_1to2.crx";
-        package.fingerprint = "22";
-        UpdateResponse::Result result;
-        result.extension_id = "ihfokbkgjpifnbbojhneepfflplebdkc";
-        result.crx_urls.push_back(GURL("http://localhost/download/"));
-        result.crx_diffurls.push_back(GURL("http://localhost/download/"));
-        result.manifest.version = "2.0";
-        result.manifest.browser_min_version = "11.0.1.0";
-        result.manifest.packages.push_back(package);
-        results.list.push_back(result);
-      } else {
-        NOTREACHED();
-      }
-
-      base::ThreadTaskRunnerHandle::Get()->PostTask(
-          FROM_HERE, base::Bind(update_check_callback, GURL(), 0, "", results));
-      return true;
-    }
-  };
-
-  class FakeCrxDownloader : public CrxDownloader {
-   public:
-    static scoped_ptr<CrxDownloader> Create(
-        bool is_background_download,
-        net::URLRequestContextGetter* context_getter,
-        const scoped_refptr<base::SequencedTaskRunner>& url_fetcher_task_runner,
-        const scoped_refptr<base::SingleThreadTaskRunner>&
-            background_task_runner) {
-      return scoped_ptr<CrxDownloader>(new FakeCrxDownloader());
-    }
-
-   private:
-    FakeCrxDownloader() : CrxDownloader(scoped_ptr<CrxDownloader>().Pass()) {}
-    ~FakeCrxDownloader() override {}
-
-    void DoStartDownload(const GURL& url) override {
-      DownloadMetrics download_metrics;
-      FilePath path;
-      Result result;
-      if (url.path() == "/download/ihfokbkgjpifnbbojhneepfflplebdkc_1.crx") {
-        download_metrics.url = url;
-        download_metrics.downloader = DownloadMetrics::kNone;
-        download_metrics.error = 0;
-        download_metrics.downloaded_bytes = 53638;
-        download_metrics.total_bytes = 53638;
-        download_metrics.download_time_ms = 2000;
-
-        EXPECT_TRUE(MakeTestFile(
-            TestFilePath("ihfokbkgjpifnbbojhneepfflplebdkc_1.crx"), &path));
-
-        result.error = 0;
-        result.response = path;
-        result.downloaded_bytes = 53638;
-        result.total_bytes = 53638;
-      } else if (url.path() ==
-                 "/download/ihfokbkgjpifnbbojhneepfflplebdkc_1to2.crx") {
-        download_metrics.url = url;
-        download_metrics.downloader = DownloadMetrics::kNone;
-        download_metrics.error = 0;
-        download_metrics.downloaded_bytes = 2105;
-        download_metrics.total_bytes = 2105;
-        download_metrics.download_time_ms = 1000;
-
-        EXPECT_TRUE(MakeTestFile(
-            TestFilePath("ihfokbkgjpifnbbojhneepfflplebdkc_1to2.crx"), &path));
-
-        result.error = 0;
-        result.response = path;
-        result.downloaded_bytes = 2105;
-        result.total_bytes = 2105;
-      } else {
-        NOTREACHED();
-      }
-
-      base::ThreadTaskRunnerHandle::Get()->PostTask(
-          FROM_HERE, base::Bind(&FakeCrxDownloader::OnDownloadProgress,
-                                base::Unretained(this), result));
-
-      base::ThreadTaskRunnerHandle::Get()->PostTask(
-          FROM_HERE,
-          base::Bind(&FakeCrxDownloader::OnDownloadComplete,
-                     base::Unretained(this), true, result, download_metrics));
-    }
-  };
-
-  class FakePingManager : public FakePingManagerImpl {
-   public:
-    explicit FakePingManager(const Configurator& config)
-        : FakePingManagerImpl(config) {}
-    ~FakePingManager() override {
-      const auto& ping_items = items();
-      EXPECT_EQ(2U, ping_items.size());
-      EXPECT_EQ("ihfokbkgjpifnbbojhneepfflplebdkc", ping_items[0].id);
-      EXPECT_TRUE(base::Version("0.8").Equals(ping_items[0].previous_version));
-      EXPECT_TRUE(base::Version("1.0").Equals(ping_items[0].next_version));
-      EXPECT_EQ(0, ping_items[0].error_category);
-      EXPECT_EQ(0, ping_items[0].error_code);
-      EXPECT_EQ("ihfokbkgjpifnbbojhneepfflplebdkc", ping_items[1].id);
-      EXPECT_TRUE(base::Version("1.0").Equals(ping_items[1].previous_version));
-      EXPECT_TRUE(base::Version("2.0").Equals(ping_items[1].next_version));
-      EXPECT_EQ(0, ping_items[1].diff_error_category);
-      EXPECT_EQ(0, ping_items[1].diff_error_code);
-    }
-  };
-
-  scoped_ptr<FakePingManager> ping_manager(new FakePingManager(*config_));
-  scoped_ptr<UpdateClient> update_client(new UpdateClientImpl(
-      config_, ping_manager.Pass(), &FakeUpdateChecker::Create,
-      &FakeCrxDownloader::Create));
-
-  MockObserver observer;
-  {
-    InSequence seq;
-    EXPECT_CALL(observer, OnEvent(Events::COMPONENT_CHECKING_FOR_UPDATES,
-                                  "ihfokbkgjpifnbbojhneepfflplebdkc")).Times(1);
-    EXPECT_CALL(observer, OnEvent(Events::COMPONENT_UPDATE_FOUND,
-                                  "ihfokbkgjpifnbbojhneepfflplebdkc")).Times(1);
-    EXPECT_CALL(observer, OnEvent(Events::COMPONENT_UPDATE_DOWNLOADING,
-                                  "ihfokbkgjpifnbbojhneepfflplebdkc")).Times(1);
-    EXPECT_CALL(observer, OnEvent(Events::COMPONENT_UPDATE_READY,
-                                  "ihfokbkgjpifnbbojhneepfflplebdkc")).Times(1);
-    EXPECT_CALL(observer, OnEvent(Events::COMPONENT_UPDATED,
-                                  "ihfokbkgjpifnbbojhneepfflplebdkc")).Times(1);
-    EXPECT_CALL(observer, OnEvent(Events::COMPONENT_CHECKING_FOR_UPDATES,
-                                  "ihfokbkgjpifnbbojhneepfflplebdkc")).Times(1);
-    EXPECT_CALL(observer, OnEvent(Events::COMPONENT_UPDATE_FOUND,
-                                  "ihfokbkgjpifnbbojhneepfflplebdkc")).Times(1);
-    EXPECT_CALL(observer, OnEvent(Events::COMPONENT_UPDATE_DOWNLOADING,
-                                  "ihfokbkgjpifnbbojhneepfflplebdkc")).Times(1);
-    EXPECT_CALL(observer, OnEvent(Events::COMPONENT_UPDATE_READY,
-                                  "ihfokbkgjpifnbbojhneepfflplebdkc")).Times(1);
-    EXPECT_CALL(observer, OnEvent(Events::COMPONENT_UPDATED,
-                                  "ihfokbkgjpifnbbojhneepfflplebdkc")).Times(1);
-  }
-
-  update_client->AddObserver(&observer);
-
-  std::vector<std::string> ids;
-  ids.push_back(std::string("ihfokbkgjpifnbbojhneepfflplebdkc"));
-
-  {
-    base::RunLoop runloop;
-    update_client->Update(
-        ids, base::Bind(&DataCallbackFake::Callback),
-        base::Bind(&CompletionCallbackFake::Callback, runloop.QuitClosure()));
-    runloop.Run();
-  }
-
-  {
-    base::RunLoop runloop;
-    update_client->Update(
-        ids, base::Bind(&DataCallbackFake::Callback),
-        base::Bind(&CompletionCallbackFake::Callback, runloop.QuitClosure()));
-    runloop.Run();
-  }
-
-  update_client->RemoveObserver(&observer);
-}
-
-// Tests the update scenario for one CRX where the CRX installer returns
-// an error.
-TEST_F(UpdateClientTest, OneCrxInstallError) {
-  class MockInstaller : public CrxInstaller {
-   public:
-    MOCK_METHOD1(OnUpdateError, void(int error));
-    MOCK_METHOD2(Install,
-                 bool(const base::DictionaryValue& manifest,
-                      const base::FilePath& unpack_path));
-    MOCK_METHOD2(GetInstalledFile,
-                 bool(const std::string& file, base::FilePath* installed_file));
-    MOCK_METHOD0(Uninstall, bool());
-
-    static void OnInstall(const base::DictionaryValue& manifest,
-                          const base::FilePath& unpack_path) {
-      base::DeleteFile(unpack_path, true);
-    }
-
-   protected:
-    ~MockInstaller() override {}
-  };
-
-  class DataCallbackFake {
-   public:
-    static void Callback(const std::vector<std::string>& ids,
-                         std::vector<CrxComponent>* components) {
-      scoped_refptr<MockInstaller> installer(new MockInstaller());
-
-      EXPECT_CALL(*installer, OnUpdateError(_)).Times(0);
-      EXPECT_CALL(*installer, Install(_, _))
-          .WillOnce(DoAll(Invoke(MockInstaller::OnInstall), Return(false)));
-      EXPECT_CALL(*installer, GetInstalledFile(_, _)).Times(0);
-      EXPECT_CALL(*installer, Uninstall()).Times(0);
-
-      CrxComponent crx;
-      crx.name = "test_jebg";
-      crx.pk_hash.assign(jebg_hash, jebg_hash + arraysize(jebg_hash));
-      crx.version = Version("0.9");
-      crx.installer = installer;
-      components->push_back(crx);
-    }
-  };
-
-  class CompletionCallbackFake {
-   public:
-    static void Callback(const base::Closure& quit_closure, int error) {
-      EXPECT_EQ(0, error);
-      quit_closure.Run();
-    }
-  };
-
-  class FakeUpdateChecker : public UpdateChecker {
-   public:
-    static scoped_ptr<UpdateChecker> Create(const Configurator& config) {
-      return scoped_ptr<UpdateChecker>(new FakeUpdateChecker());
-    }
-
-    bool CheckForUpdates(
-        const std::vector<CrxUpdateItem*>& items_to_check,
-        const std::string& additional_attributes,
-        const UpdateCheckCallback& update_check_callback) override {
-      /*
-      Fake the following response:
-
-      <?xml version='1.0' encoding='UTF-8'?>
-      <response protocol='3.0'>
-        <app appid='jebgalgnebhfojomionfpkfelancnnkf'>
-          <updatecheck status='ok'>
-            <urls>
-              <url codebase='http://localhost/download/'/>
-            </urls>
-            <manifest version='1.0' prodversionmin='11.0.1.0'>
-              <packages>
-                <package name='jebgalgnebhfojomionfpkfelancnnkf.crx'/>
-              </packages>
-            </manifest>
-          </updatecheck>
-        </app>
-      </response>
-      */
-      UpdateResponse::Result::Manifest::Package package;
-      package.name = "jebgalgnebhfojomionfpkfelancnnkf.crx";
-
-      UpdateResponse::Result result;
-      result.extension_id = "jebgalgnebhfojomionfpkfelancnnkf";
-      result.crx_urls.push_back(GURL("http://localhost/download/"));
-      result.manifest.version = "1.0";
-      result.manifest.browser_min_version = "11.0.1.0";
-      result.manifest.packages.push_back(package);
-
-      UpdateResponse::Results results;
-      results.list.push_back(result);
-
-      base::ThreadTaskRunnerHandle::Get()->PostTask(
-          FROM_HERE, base::Bind(update_check_callback, GURL(), 0, "", results));
-      return true;
-    }
-  };
-
-  class FakeCrxDownloader : public CrxDownloader {
-   public:
-    static scoped_ptr<CrxDownloader> Create(
-        bool is_background_download,
-        net::URLRequestContextGetter* context_getter,
-        const scoped_refptr<base::SequencedTaskRunner>& url_fetcher_task_runner,
-        const scoped_refptr<base::SingleThreadTaskRunner>&
-            background_task_runner) {
-      return scoped_ptr<CrxDownloader>(new FakeCrxDownloader());
-    }
-
-   private:
-    FakeCrxDownloader() : CrxDownloader(scoped_ptr<CrxDownloader>().Pass()) {}
-    ~FakeCrxDownloader() override {}
-
-    void DoStartDownload(const GURL& url) override {
-      DownloadMetrics download_metrics;
-      download_metrics.url = url;
-      download_metrics.downloader = DownloadMetrics::kNone;
-      download_metrics.error = 0;
-      download_metrics.downloaded_bytes = 1843;
-      download_metrics.total_bytes = 1843;
-      download_metrics.download_time_ms = 1000;
-
-      FilePath path;
-      EXPECT_TRUE(MakeTestFile(
-          TestFilePath("jebgalgnebhfojomionfpkfelancnnkf.crx"), &path));
-
-      Result result;
-      result.error = 0;
-      result.response = path;
-      result.downloaded_bytes = 1843;
-      result.total_bytes = 1843;
-
-      base::ThreadTaskRunnerHandle::Get()->PostTask(
-          FROM_HERE, base::Bind(&FakeCrxDownloader::OnDownloadProgress,
-                                base::Unretained(this), result));
-
-      base::ThreadTaskRunnerHandle::Get()->PostTask(
-          FROM_HERE,
-          base::Bind(&FakeCrxDownloader::OnDownloadComplete,
-                     base::Unretained(this), true, result, download_metrics));
-    }
-  };
-
-  class FakePingManager : public FakePingManagerImpl {
-   public:
-    explicit FakePingManager(const Configurator& config)
-        : FakePingManagerImpl(config) {}
-    ~FakePingManager() override {
-      const auto& ping_items = items();
-      EXPECT_EQ(1U, ping_items.size());
-      EXPECT_EQ("jebgalgnebhfojomionfpkfelancnnkf", ping_items[0].id);
-      EXPECT_TRUE(base::Version("0.9").Equals(ping_items[0].previous_version));
-      EXPECT_TRUE(base::Version("1.0").Equals(ping_items[0].next_version));
-      EXPECT_EQ(3, ping_items[0].error_category);  // kInstallError.
-      EXPECT_EQ(9, ping_items[0].error_code);      // kInstallerError.
-    }
-  };
-
-  scoped_ptr<PingManager> ping_manager(new FakePingManager(*config_));
-  scoped_ptr<UpdateClient> update_client(new UpdateClientImpl(
-      config_, ping_manager.Pass(), &FakeUpdateChecker::Create,
-      &FakeCrxDownloader::Create));
-
-  MockObserver observer;
-  {
-    InSequence seq;
-    EXPECT_CALL(observer, OnEvent(Events::COMPONENT_CHECKING_FOR_UPDATES,
-                                  "jebgalgnebhfojomionfpkfelancnnkf")).Times(1);
-    EXPECT_CALL(observer, OnEvent(Events::COMPONENT_UPDATE_FOUND,
-                                  "jebgalgnebhfojomionfpkfelancnnkf")).Times(1);
-    EXPECT_CALL(observer, OnEvent(Events::COMPONENT_UPDATE_DOWNLOADING,
-                                  "jebgalgnebhfojomionfpkfelancnnkf")).Times(1);
-    EXPECT_CALL(observer, OnEvent(Events::COMPONENT_UPDATE_READY,
-                                  "jebgalgnebhfojomionfpkfelancnnkf")).Times(1);
-    EXPECT_CALL(observer, OnEvent(Events::COMPONENT_NOT_UPDATED,
-                                  "jebgalgnebhfojomionfpkfelancnnkf")).Times(1);
-  }
-
-  update_client->AddObserver(&observer);
-
-  std::vector<std::string> ids;
-  ids.push_back(std::string("jebgalgnebhfojomionfpkfelancnnkf"));
-
-  update_client->Update(
-      ids, base::Bind(&DataCallbackFake::Callback),
-      base::Bind(&CompletionCallbackFake::Callback, quit_closure_));
-
-  RunThreads();
-
-  update_client->RemoveObserver(&observer);
-}
-
-// Tests the fallback from differential to full update scenario for one CRX.
-TEST_F(UpdateClientTest, OneCrxDiffUpdateFailsFullUpdateSucceeds) {
-  class DataCallbackFake {
-   public:
-    static void Callback(const std::vector<std::string>& ids,
-                         std::vector<CrxComponent>* components) {
-      static int num_calls = 0;
-
-      // Must use the same stateful installer object.
-      static scoped_refptr<CrxInstaller> installer(
-          new VersionedTestInstaller());
-
-      ++num_calls;
-
-      CrxComponent crx;
-      crx.name = "test_ihfo";
-      crx.pk_hash.assign(ihfo_hash, ihfo_hash + arraysize(ihfo_hash));
-      crx.installer = installer;
-      if (num_calls == 1) {
-        crx.version = Version("0.8");
-      } else if (num_calls == 2) {
-        crx.version = Version("1.0");
-      } else {
-        NOTREACHED();
-      }
-
-      components->push_back(crx);
-    }
-  };
-
-  class CompletionCallbackFake {
-   public:
-    static void Callback(const base::Closure& quit_closure, int error) {
-      EXPECT_EQ(0, error);
-      quit_closure.Run();
-    }
-  };
-
-  class FakeUpdateChecker : public UpdateChecker {
-   public:
-    static scoped_ptr<UpdateChecker> Create(const Configurator& config) {
-      return scoped_ptr<UpdateChecker>(new FakeUpdateChecker());
-    }
-
-    bool CheckForUpdates(
-        const std::vector<CrxUpdateItem*>& items_to_check,
-        const std::string& additional_attributes,
-        const UpdateCheckCallback& update_check_callback) override {
-      static int num_call = 0;
-      ++num_call;
-
-      UpdateResponse::Results results;
-
-      if (num_call == 1) {
-        /*
-        Fake the following response:
-        <?xml version='1.0' encoding='UTF-8'?>
-        <response protocol='3.0'>
-          <app appid='ihfokbkgjpifnbbojhneepfflplebdkc'>
-            <updatecheck status='ok'>
-              <urls>
-                <url codebase='http://localhost/download/'/>
-              </urls>
-              <manifest version='1.0' prodversionmin='11.0.1.0'>
-                <packages>
-                  <package name='ihfokbkgjpifnbbojhneepfflplebdkc_1.crx'/>
-                </packages>
-              </manifest>
-            </updatecheck>
-          </app>
-        </response>
-        */
-        UpdateResponse::Result::Manifest::Package package;
-        package.name = "ihfokbkgjpifnbbojhneepfflplebdkc_1.crx";
-        package.fingerprint = "1";
-        UpdateResponse::Result result;
-        result.extension_id = "ihfokbkgjpifnbbojhneepfflplebdkc";
-        result.crx_urls.push_back(GURL("http://localhost/download/"));
-        result.manifest.version = "1.0";
-        result.manifest.browser_min_version = "11.0.1.0";
-        result.manifest.packages.push_back(package);
-        results.list.push_back(result);
-      } else if (num_call == 2) {
-        /*
-        Fake the following response:
-        <?xml version='1.0' encoding='UTF-8'?>
-        <response protocol='3.0'>
-          <app appid='ihfokbkgjpifnbbojhneepfflplebdkc'>
-            <updatecheck status='ok'>
-              <urls>
-                <url codebase='http://localhost/download/'/>
-                <url codebasediff='http://localhost/download/'/>
-              </urls>
-              <manifest version='2.0' prodversionmin='11.0.1.0'>
-                <packages>
-                  <package name='ihfokbkgjpifnbbojhneepfflplebdkc_2.crx'
-                           namediff='ihfokbkgjpifnbbojhneepfflplebdkc_1to2.crx'
-                           fp='22'/>
-                </packages>
-              </manifest>
-            </updatecheck>
-          </app>
-        </response>
-        */
-        UpdateResponse::Result::Manifest::Package package;
-        package.name = "ihfokbkgjpifnbbojhneepfflplebdkc_2.crx";
-        package.namediff = "ihfokbkgjpifnbbojhneepfflplebdkc_1to2.crx";
-        package.fingerprint = "22";
-        UpdateResponse::Result result;
-        result.extension_id = "ihfokbkgjpifnbbojhneepfflplebdkc";
-        result.crx_urls.push_back(GURL("http://localhost/download/"));
-        result.crx_diffurls.push_back(GURL("http://localhost/download/"));
-        result.manifest.version = "2.0";
-        result.manifest.browser_min_version = "11.0.1.0";
-        result.manifest.packages.push_back(package);
-        results.list.push_back(result);
-      } else {
-        NOTREACHED();
-      }
-
-      base::ThreadTaskRunnerHandle::Get()->PostTask(
-          FROM_HERE, base::Bind(update_check_callback, GURL(), 0, "", results));
-      return true;
-    }
-  };
-
-  class FakeCrxDownloader : public CrxDownloader {
-   public:
-    static scoped_ptr<CrxDownloader> Create(
-        bool is_background_download,
-        net::URLRequestContextGetter* context_getter,
-        const scoped_refptr<base::SequencedTaskRunner>& url_fetcher_task_runner,
-        const scoped_refptr<base::SingleThreadTaskRunner>&
-            background_task_runner) {
-      return scoped_ptr<CrxDownloader>(new FakeCrxDownloader());
-    }
-
-   private:
-    FakeCrxDownloader() : CrxDownloader(scoped_ptr<CrxDownloader>().Pass()) {}
-    ~FakeCrxDownloader() override {}
-
-    void DoStartDownload(const GURL& url) override {
-      DownloadMetrics download_metrics;
-      FilePath path;
-      Result result;
-      if (url.path() == "/download/ihfokbkgjpifnbbojhneepfflplebdkc_1.crx") {
-        download_metrics.url = url;
-        download_metrics.downloader = DownloadMetrics::kNone;
-        download_metrics.error = 0;
-        download_metrics.downloaded_bytes = 53638;
-        download_metrics.total_bytes = 53638;
-        download_metrics.download_time_ms = 2000;
-
-        EXPECT_TRUE(MakeTestFile(
-            TestFilePath("ihfokbkgjpifnbbojhneepfflplebdkc_1.crx"), &path));
-
-        result.error = 0;
-        result.response = path;
-        result.downloaded_bytes = 53638;
-        result.total_bytes = 53638;
-      } else if (url.path() ==
-                 "/download/ihfokbkgjpifnbbojhneepfflplebdkc_1to2.crx") {
-        // A download error is injected on this execution path.
-        download_metrics.url = url;
-        download_metrics.downloader = DownloadMetrics::kNone;
-        download_metrics.error = -1;
-        download_metrics.downloaded_bytes = 0;
-        download_metrics.total_bytes = 2105;
-        download_metrics.download_time_ms = 1000;
-
-        EXPECT_TRUE(MakeTestFile(
-            TestFilePath("ihfokbkgjpifnbbojhneepfflplebdkc_1to2.crx"), &path));
-
-        result.error = -1;
-        result.response = path;
-        result.downloaded_bytes = 0;
-        result.total_bytes = 2105;
-      } else if (url.path() ==
-                 "/download/ihfokbkgjpifnbbojhneepfflplebdkc_2.crx") {
-        download_metrics.url = url;
-        download_metrics.downloader = DownloadMetrics::kNone;
-        download_metrics.error = 0;
-        download_metrics.downloaded_bytes = 53855;
-        download_metrics.total_bytes = 53855;
-        download_metrics.download_time_ms = 1000;
-
-        EXPECT_TRUE(MakeTestFile(
-            TestFilePath("ihfokbkgjpifnbbojhneepfflplebdkc_2.crx"), &path));
-
-        result.error = 0;
-        result.response = path;
-        result.downloaded_bytes = 53855;
-        result.total_bytes = 53855;
-      }
-
-      base::ThreadTaskRunnerHandle::Get()->PostTask(
-          FROM_HERE, base::Bind(&FakeCrxDownloader::OnDownloadProgress,
-                                base::Unretained(this), result));
-
-      base::ThreadTaskRunnerHandle::Get()->PostTask(
-          FROM_HERE,
-          base::Bind(&FakeCrxDownloader::OnDownloadComplete,
-                     base::Unretained(this), true, result, download_metrics));
-    }
-  };
-
-  class FakePingManager : public FakePingManagerImpl {
-   public:
-    explicit FakePingManager(const Configurator& config)
-        : FakePingManagerImpl(config) {}
-    ~FakePingManager() override {
-      const auto& ping_items = items();
-      EXPECT_EQ(2U, ping_items.size());
-      EXPECT_EQ("ihfokbkgjpifnbbojhneepfflplebdkc", ping_items[0].id);
-      EXPECT_TRUE(base::Version("0.8").Equals(ping_items[0].previous_version));
-      EXPECT_TRUE(base::Version("1.0").Equals(ping_items[0].next_version));
-      EXPECT_EQ(0, ping_items[0].error_category);
-      EXPECT_EQ(0, ping_items[0].error_code);
-      EXPECT_EQ("ihfokbkgjpifnbbojhneepfflplebdkc", ping_items[1].id);
-      EXPECT_TRUE(base::Version("1.0").Equals(ping_items[1].previous_version));
-      EXPECT_TRUE(base::Version("2.0").Equals(ping_items[1].next_version));
-      EXPECT_TRUE(ping_items[1].diff_update_failed);
-      EXPECT_EQ(1, ping_items[1].diff_error_category);  // kNetworkError.
-      EXPECT_EQ(-1, ping_items[1].diff_error_code);
-    }
-  };
-
-  scoped_ptr<FakePingManager> ping_manager(new FakePingManager(*config_));
-  scoped_ptr<UpdateClient> update_client(new UpdateClientImpl(
-      config_, ping_manager.Pass(), &FakeUpdateChecker::Create,
-      &FakeCrxDownloader::Create));
-
-  MockObserver observer;
-  {
-    InSequence seq;
-    EXPECT_CALL(observer, OnEvent(Events::COMPONENT_CHECKING_FOR_UPDATES,
-                                  "ihfokbkgjpifnbbojhneepfflplebdkc")).Times(1);
-    EXPECT_CALL(observer, OnEvent(Events::COMPONENT_UPDATE_FOUND,
-                                  "ihfokbkgjpifnbbojhneepfflplebdkc")).Times(1);
-    EXPECT_CALL(observer, OnEvent(Events::COMPONENT_UPDATE_DOWNLOADING,
-                                  "ihfokbkgjpifnbbojhneepfflplebdkc")).Times(1);
-    EXPECT_CALL(observer, OnEvent(Events::COMPONENT_UPDATE_READY,
-                                  "ihfokbkgjpifnbbojhneepfflplebdkc")).Times(1);
-    EXPECT_CALL(observer, OnEvent(Events::COMPONENT_UPDATED,
-                                  "ihfokbkgjpifnbbojhneepfflplebdkc")).Times(1);
-
-    EXPECT_CALL(observer, OnEvent(Events::COMPONENT_CHECKING_FOR_UPDATES,
-                                  "ihfokbkgjpifnbbojhneepfflplebdkc")).Times(1);
-    EXPECT_CALL(observer, OnEvent(Events::COMPONENT_UPDATE_FOUND,
-                                  "ihfokbkgjpifnbbojhneepfflplebdkc")).Times(1);
-    EXPECT_CALL(observer, OnEvent(Events::COMPONENT_UPDATE_DOWNLOADING,
-                                  "ihfokbkgjpifnbbojhneepfflplebdkc")).Times(1);
-    EXPECT_CALL(observer, OnEvent(Events::COMPONENT_UPDATE_DOWNLOADING,
-                                  "ihfokbkgjpifnbbojhneepfflplebdkc")).Times(1);
-    EXPECT_CALL(observer, OnEvent(Events::COMPONENT_UPDATE_READY,
-                                  "ihfokbkgjpifnbbojhneepfflplebdkc")).Times(1);
-    EXPECT_CALL(observer, OnEvent(Events::COMPONENT_UPDATED,
-                                  "ihfokbkgjpifnbbojhneepfflplebdkc")).Times(1);
-  }
-
-  update_client->AddObserver(&observer);
-
-  std::vector<std::string> ids;
-  ids.push_back(std::string("ihfokbkgjpifnbbojhneepfflplebdkc"));
-
-  {
-    base::RunLoop runloop;
-    update_client->Update(
-        ids, base::Bind(&DataCallbackFake::Callback),
-        base::Bind(&CompletionCallbackFake::Callback, runloop.QuitClosure()));
-    runloop.Run();
-  }
-
-  {
-    base::RunLoop runloop;
-    update_client->Update(
-        ids, base::Bind(&DataCallbackFake::Callback),
-        base::Bind(&CompletionCallbackFake::Callback, runloop.QuitClosure()));
-    runloop.Run();
-  }
-
-  update_client->RemoveObserver(&observer);
-}
-
-}  // namespace update_client
diff --git a/components/update_client/update_checker.h b/components/update_client/update_checker.h
index 2f4b868..1ac6426 100644
--- a/components/update_client/update_checker.h
+++ b/components/update_client/update_checker.h
@@ -27,13 +27,11 @@ struct CrxUpdateItem;
 
 class UpdateChecker {
  public:
-  using UpdateCheckCallback =
-      base::Callback<void(const GURL& original_url,
-                          int error,
-                          const std::string& error_message,
-                          const UpdateResponse::Results& results)>;
-
-  using Factory = scoped_ptr<UpdateChecker>(*)(const Configurator& config);
+  typedef base::Callback<void(const GURL& original_url,
+                              int error,
+                              const std::string& error_message,
+                              const UpdateResponse::Results& results)>
+      UpdateCheckCallback;
 
   virtual ~UpdateChecker() {}
 
diff --git a/components/update_client/update_client.cc b/components/update_client/update_client.cc
index ce857e1..35cc5bb 100644
--- a/components/update_client/update_client.cc
+++ b/components/update_client/update_client.cc
@@ -4,40 +4,12 @@
 
 #include "components/update_client/update_client.h"
 
-#include <algorithm>
-#include <queue>
-#include <set>
-#include <utility>
-#include <vector>
-
-#include "base/bind.h"
-#include "base/bind_helpers.h"
-#include "base/callback.h"
-#include "base/compiler_specific.h"
-#include "base/location.h"
-#include "base/logging.h"
-#include "base/macros.h"
-#include "base/observer_list.h"
-#include "base/sequenced_task_runner.h"
-#include "base/single_thread_task_runner.h"
-#include "base/thread_task_runner_handle.h"
-#include "base/threading/sequenced_worker_pool.h"
-#include "base/threading/thread_checker.h"
-#include "components/update_client/configurator.h"
 #include "components/update_client/crx_update_item.h"
-#include "components/update_client/ping_manager.h"
-#include "components/update_client/task_update.h"
-#include "components/update_client/update_checker.h"
-#include "components/update_client/update_client_internal.h"
-#include "components/update_client/update_engine.h"
-#include "components/update_client/update_response.h"
-#include "components/update_client/utils.h"
-#include "url/gurl.h"
 
 namespace update_client {
 
 CrxUpdateItem::CrxUpdateItem()
-    : state(State::kNew),
+    : status(kNew),
       unregistered(false),
       on_demand(false),
       diff_update_failed(false),
@@ -58,122 +30,4 @@ CrxComponent::CrxComponent() : allow_background_download(true) {
 CrxComponent::~CrxComponent() {
 }
 
-UpdateClientImpl::UpdateClientImpl(
-    const scoped_refptr<Configurator>& config,
-    scoped_ptr<PingManager> ping_manager,
-    UpdateChecker::Factory update_checker_factory,
-    CrxDownloader::Factory crx_downloader_factory)
-    : config_(config),
-      ping_manager_(ping_manager.Pass()),
-      update_engine_(
-          new UpdateEngine(config,
-                           update_checker_factory,
-                           crx_downloader_factory,
-                           ping_manager_.get(),
-                           base::Bind(&UpdateClientImpl::NotifyObservers,
-                                      base::Unretained(this)))) {
-}
-
-UpdateClientImpl::~UpdateClientImpl() {
-  DCHECK(thread_checker_.CalledOnValidThread());
-  config_ = nullptr;
-}
-
-void UpdateClientImpl::Install(const std::string& id,
-                               const CrxDataCallback& crx_data_callback,
-                               const CompletionCallback& completion_callback) {
-  DCHECK(thread_checker_.CalledOnValidThread());
-
-  if (update_engine_->IsUpdating(id)) {
-    completion_callback.Run(Error::ERROR_UPDATE_IN_PROGRESS);
-    return;
-  }
-
-  std::vector<std::string> ids;
-  ids.push_back(id);
-
-  scoped_ptr<TaskUpdate> task(
-      new TaskUpdate(update_engine_.get(), ids, crx_data_callback));
-
-  auto it = tasks_.insert(task.release()).first;
-  RunTask(*it, completion_callback);
-}
-
-void UpdateClientImpl::Update(const std::vector<std::string>& ids,
-                              const CrxDataCallback& crx_data_callback,
-                              const CompletionCallback& completion_callback) {
-  DCHECK(thread_checker_.CalledOnValidThread());
-
-  scoped_ptr<TaskUpdate> task(
-      new TaskUpdate(update_engine_.get(), ids, crx_data_callback));
-  if (tasks_.empty()) {
-    auto it = tasks_.insert(task.release()).first;
-    RunTask(*it, completion_callback);
-  } else {
-    task_queue_.push(task.release());
-  }
-}
-
-void UpdateClientImpl::RunTask(Task* task,
-                               const CompletionCallback& completion_callback) {
-  DCHECK(thread_checker_.CalledOnValidThread());
-  base::ThreadTaskRunnerHandle::Get()->PostTask(
-      FROM_HERE,
-      base::Bind(&Task::Run, base::Unretained(task),
-                 base::Bind(&UpdateClientImpl::OnTaskComplete,
-                            base::Unretained(this), completion_callback)));
-}
-
-void UpdateClientImpl::OnTaskComplete(
-    const CompletionCallback& completion_callback,
-    Task* task,
-    int error) {
-  DCHECK(thread_checker_.CalledOnValidThread());
-  DCHECK(task);
-
-  base::ThreadTaskRunnerHandle::Get()->PostTask(
-      FROM_HERE, base::Bind(completion_callback, error));
-
-  tasks_.erase(task);
-  delete task;
-
-  if (!task_queue_.empty()) {
-    RunTask(task_queue_.front(), completion_callback);
-    task_queue_.pop();
-  }
-}
-
-void UpdateClientImpl::AddObserver(Observer* observer) {
-  DCHECK(thread_checker_.CalledOnValidThread());
-  observer_list_.AddObserver(observer);
-}
-
-void UpdateClientImpl::RemoveObserver(Observer* observer) {
-  DCHECK(thread_checker_.CalledOnValidThread());
-  observer_list_.RemoveObserver(observer);
-}
-
-void UpdateClientImpl::NotifyObservers(Observer::Events event,
-                                       const std::string& id) {
-  DCHECK(thread_checker_.CalledOnValidThread());
-  FOR_EACH_OBSERVER(Observer, observer_list_, OnEvent(event, id));
-}
-
-bool UpdateClientImpl::GetCrxUpdateState(const std::string& id,
-                                         CrxUpdateItem* update_item) const {
-  return update_engine_->GetUpdateState(id, update_item);
-}
-
-bool UpdateClientImpl::IsUpdating(const std::string& id) const {
-  return update_engine_->IsUpdating(id);
-}
-
-scoped_ptr<UpdateClient> UpdateClientFactory(
-    const scoped_refptr<Configurator>& config) {
-  scoped_ptr<PingManager> ping_manager(new PingManager(*config));
-  return scoped_ptr<UpdateClient>(
-      new UpdateClientImpl(config, ping_manager.Pass(), &UpdateChecker::Create,
-                           &CrxDownloader::Create));
-}
-
 }  // namespace update_client
diff --git a/components/update_client/update_client.h b/components/update_client/update_client.h
index 100bbcc..35b3cca 100644
--- a/components/update_client/update_client.h
+++ b/components/update_client/update_client.h
@@ -9,126 +9,9 @@
 #include <string>
 #include <vector>
 
-#include "base/callback_forward.h"
 #include "base/memory/ref_counted.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/version.h"
 
-// The UpdateClient class is a facade with a simple interface. The interface
-// exposes a few APIs to install a CRX or update a group of CRXs.
-//
-// The difference between a CRX install and a CRX update is relatively minor.
-// The terminology going forward will use the word "update" to cover both
-// install and update scenarios, except where details regarding the install
-// case are relevant.
-//
-// Handling an update consists of a series of actions such as sending an update
-// check to the server, followed by parsing the server response, identifying
-// the CRXs that require an update, downloading the differential update if
-// it is available, unpacking and patching the differential update, then
-// falling back to trying a similar set of actions using the full update.
-// At the end of this process, completion pings are sent to the server,
-// as needed, for the CRXs which had updates.
-//
-// As a general idea, this code handles the action steps needed to update
-// a group of components serially, one step at a time. However, concurrent
-// execution of calls to UpdateClient::Update is possible, therefore,
-// queuing of updates could happen in some cases. More below.
-//
-// The UpdateClient class features a subject-observer interface to observe
-// the CRX state changes during an update.
-//
-// The threading model for this code assumes that most of the code in the
-// public interface runs on a SingleThreadTaskRunner.
-// This task runner corresponds to the browser UI thread in many cases. There
-// are parts of the installer interface that run on blocking task runners, which
-// are usually threads in a thread pool.
-//
-// Using the UpdateClient is relatively easy. This assumes that the client
-// of this code has already implemented the observer interface as needed, and
-// can provide an installer, as described below.
-//
-//    scoped_ptr<UpdateClient> update_client(UpdateClientFactory(...));
-//    update_client->AddObserver(&observer);
-//    std::vector<std::string> ids;
-//    ids.push_back(...));
-//    update_client->Update(ids, base::Bind(...), base::Bind(...));
-//
-// UpdateClient::Update takes two callbacks as parameters. First callback
-// allows the client of this code to provide an instance of CrxComponent
-// data structure that specifies additional parameters of the update.
-// CrxComponent has a CrxInstaller data member, which must be provided by the
-// callers of this class. The second callback indicates that this non-blocking
-// call has completed.
-//
-// There could be several ways of triggering updates for a CRX, user-initiated,
-// or timer-based. Since the execution of updates is concurrent, the parameters
-// for the update must be provided right before the update is handled.
-// Otherwise, the version of the CRX set in the CrxComponent may not be correct.
-//
-// The UpdateClient public interface includes two functions: Install and
-// Update. These functions correspond to installing one CRX immediately as a
-// foreground activity (Install), and updating a group of CRXs silently in the
-// background (Update). This distinction is important. Background updates are
-// queued up and their actions run serially, one at a time, for the purpose of
-// conserving local resources such as CPU, network, and I/O.
-// On the other hand, installs are never queued up but run concurrently, as
-// requested by the user.
-//
-// The update client introduces a runtime constraint regarding interleaving
-// updates and installs. If installs or updates for a given CRX are in progress,
-// then installs for the same CRX will fail with a specific error.
-//
-// Implementation details.
-//
-// The implementation details below are not relevant to callers of this
-// code. However, these design notes are relevant to the owners and maintainers
-// of this module.
-//
-// The design for the update client consists of a number of abstractions
-// such as: task, update engine, update context, and action.
-// The execution model for these abstractions is simple. They usually expose
-// a public, non-blocking Run function, and they invoke a callback when
-// the Run function has completed.
-//
-// A task is the unit of work for the UpdateClient. A task is associated
-// with a single call of the Update function. A task represents a group
-// of CRXs that are updated together.
-//
-// The UpdateClient is responsible for the queuing of tasks, if queuing is
-// needed.
-//
-// When the task runs, it calls the update engine to handle the updates for
-// the CRXs associated with the task. The UpdateEngine is the abstraction
-// responsible for breaking down the update in a set of discrete steps, which
-// are implemented as actions, and running the actions.
-//
-// The UpdateEngine maintains a set of UpdateContext instances. Each of
-// these instances maintains the update state for all the CRXs belonging to
-// a given task. The UpdateContext contains a queue of CRX ids.
-// The UpdateEngine will handle updates for the CRXs in the order they appear
-// in the queue, until the queue is empty.
-//
-// The update state for each CRX is maintained in a container of CrxUpdateItem*.
-// As actions run, each action updates the CRX state, represented by one of
-// these CrxUpdateItem* instances.
-//
-// Although the UpdateEngine can and will run update tasks concurrently, the
-// actions of a task are run sequentially.
-//
-// The Action is a polymorphic type. There is some code reuse for convenience,
-// implemented as a mixin. The polymorphic behavior of some of the actions
-// is achieved using a template method.
-//
-// State changes of a CRX could generate events, which are observed using a
-// subject-observer interface.
-//
-// The actions chain up. In some sense, the actions implement a state machine,
-// as the CRX undergoes a series of state transitions in the process of
-// being checked for updates and applying the update.
-
-class ComponentsUI;
-
 namespace base {
 class DictionaryValue;
 class FilePath;
@@ -136,161 +19,63 @@ class FilePath;
 
 namespace update_client {
 
-class Configurator;
-struct CrxUpdateItem;
-
-enum Error {
-  ERROR_UPDATE_IN_PROGRESS = 1,
-};
-
-// Defines an interface for a generic CRX installer.
-class CrxInstaller : public base::RefCountedThreadSafe<CrxInstaller> {
+// Component specific installers must derive from this class and implement
+// OnUpdateError() and Install(). A valid instance of this class must be
+// given to ComponentUpdateService::RegisterComponent().
+class ComponentInstaller
+    : public base::RefCountedThreadSafe<ComponentInstaller> {
  public:
-  // Called on the main thread when there was a problem unpacking or
-  // verifying the CRX. |error| is a non-zero value which is only meaningful
-  // to the caller.
+  // Called by the component updater on the main thread when there was a
+  // problem unpacking or verifying the component. |error| is a non-zero
+  // value which is only meaningful to the component updater.
   virtual void OnUpdateError(int error) = 0;
 
-  // Called by the update service when a CRX has been unpacked
-  // and it is ready to be installed. |manifest| contains the CRX manifest
-  // as a json dictionary.|unpack_path| contains the temporary directory
-  // with all the unpacked CRX files.
-  // This method may be called from a thread other than the main thread.
+  // Called by the component updater when a component has been unpacked
+  // and is ready to be installed. |manifest| contains the CRX manifest
+  // json dictionary and |unpack_path| contains the temporary directory
+  // with all the unpacked CRX files. This method may be called from
+  // a thread other than the main thread.
   virtual bool Install(const base::DictionaryValue& manifest,
                        const base::FilePath& unpack_path) = 0;
 
-  // Sets |installed_file| to the full path to the installed |file|. |file| is
-  // the filename of the file in this CRX. Returns false if this is
+  // Set |installed_file| to the full path to the installed |file|. |file| is
+  // the filename of the file in this component's CRX. Returns false if this is
   // not possible (the file has been removed or modified, or its current
-  // location is unknown). Otherwise, it returns true.
+  // location is unknown). Otherwise, returns true.
   virtual bool GetInstalledFile(const std::string& file,
                                 base::FilePath* installed_file) = 0;
 
-  // Called when a CRX has been unregistered and all versions should
-  // be uninstalled from disk. Returns true if uninstallation is supported,
-  // and false otherwise.
+  // Called by the component updater when a component has been unregistered and
+  // all versions should be uninstalled from disk. Returns true if
+  // uninstallation is supported, false otherwise.
   virtual bool Uninstall() = 0;
 
  protected:
-  friend class base::RefCountedThreadSafe<CrxInstaller>;
+  friend class base::RefCountedThreadSafe<ComponentInstaller>;
 
-  virtual ~CrxInstaller() {}
+  virtual ~ComponentInstaller() {}
 };
 
-// TODO(sorin): this structure will be refactored soon.
+// Describes a particular component that can be installed or updated. This
+// structure is required to register a component with the component updater.
+// |pk_hash| is the SHA256 hash of the component's public key. If the component
+// is to be installed then version should be "0" or "0.0", else it should be
+// the current version. |fingerprint|, and |name| are optional.
+// |allow_background_download| specifies that the component can be background
+// downloaded in some cases. The default for this value is |true| and the value
+// can be overriden at the registration time. This is a temporary change until
+// the issue 340448 is resolved.
 struct CrxComponent {
-  CrxComponent();
-  ~CrxComponent();
-
-  // SHA256 hash of the CRX's public key.
   std::vector<uint8_t> pk_hash;
-  scoped_refptr<CrxInstaller> installer;
-
-  // The current version if the CRX is updated. Otherwise, "0" or "0.0" if
-  // the CRX is installed.
+  scoped_refptr<ComponentInstaller> installer;
   Version version;
-
-  std::string fingerprint;  // Optional.
-  std::string name;         // Optional.
-
-  // Specifies that the CRX can be background-downloaded in some cases.
-  // The default for this value is |true| and the value can be overriden at
-  // the registration time. This is a temporary change until the issue
-  // crbug/340448 is resolved.
+  std::string fingerprint;
+  std::string name;
   bool allow_background_download;
+  CrxComponent();
+  ~CrxComponent();
 };
 
-// All methods are safe to call only from the browser's main thread.
-class UpdateClient {
- public:
-  using CrxDataCallback =
-      base::Callback<void(const std::vector<std::string>& ids,
-                          std::vector<CrxComponent>* components)>;
-  using CompletionCallback = base::Callback<void(int error)>;
-
-  // Defines an interface to observe the UpdateClient. It provides
-  // notifications when state changes occur for the service itself or for the
-  // registered CRXs.
-  class Observer {
-   public:
-    enum class Events {
-      // Sent before the update client does an update check.
-      COMPONENT_CHECKING_FOR_UPDATES,
-
-      // Sent when there is a new version of a registered CRX. After
-      // the notification is sent the CRX will be downloaded unless the
-      // update client inserts a
-      COMPONENT_UPDATE_FOUND,
-
-      // Sent when a CRX is in the update queue but it can't be acted on
-      // right away, because the update client spaces out CRX updates due to a
-      // throttling policy.
-      COMPONENT_WAIT,
-
-      // Sent after the new CRX has been downloaded but before the install
-      // or the upgrade is attempted.
-      COMPONENT_UPDATE_READY,
-
-      // Sent when a CRX has been successfully updated.
-      COMPONENT_UPDATED,
-
-      // Sent when a CRX has not been updated following an update check:
-      // either there was no update available, or the update failed.
-      COMPONENT_NOT_UPDATED,
-
-      // Sent when CRX bytes are being downloaded.
-      COMPONENT_UPDATE_DOWNLOADING,
-    };
-
-    virtual ~Observer() {}
-
-    // Called by the update client when a state change happens.
-    // If an |id| is specified, then the event is fired on behalf of the
-    // specific CRX. The implementors of this interface are
-    // expected to filter the relevant events based on the id of the CRX.
-    virtual void OnEvent(Events event, const std::string& id) = 0;
-  };
-
-  // Adds an observer for this class. An observer should not be added more
-  // than once. The caller retains the ownership of the observer object.
-  virtual void AddObserver(Observer* observer) = 0;
-
-  // Removes an observer. It is safe for an observer to be removed while
-  // the observers are being notified.
-  virtual void RemoveObserver(Observer* observer) = 0;
-
-  // Installs the specified CRX. Calls back after the install has been handled.
-  // Calls back on |completion_callback| after the update has been handled. The
-  // |error| parameter of the |completion_callback| contains an error code in
-  // the case of a run-time error, or 0 if the Install has been handled
-  // successfully.
-  virtual void Install(const std::string& id,
-                       const CrxDataCallback& crx_data_callback,
-                       const CompletionCallback& completion_callback) = 0;
-
-  // Updates the specified CRXs. Calls back on |crx_data_callback| before the
-  // update is attempted to give the caller the opportunity to provide the
-  // instances of CrxComponent to be used for this update.
-  virtual void Update(const std::vector<std::string>& ids,
-                      const CrxDataCallback& crx_data_callback,
-                      const CompletionCallback& completion_callback) = 0;
-
-  // Returns status details about a CRX update. The function returns true in
-  // case of success and false in case of errors, such as |id| was
-  // invalid or not known.
-  virtual bool GetCrxUpdateState(const std::string& id,
-                                 CrxUpdateItem* update_item) const = 0;
-
-  virtual bool IsUpdating(const std::string& id) const = 0;
-
-  virtual ~UpdateClient() {}
-};
-
-// Creates an instance of the update client.
-// TODO(sorin): make UpdateClient a ref counted type.
-scoped_ptr<UpdateClient> UpdateClientFactory(
-    const scoped_refptr<Configurator>& config);
-
 }  // namespace update_client
 
 #endif  // COMPONENTS_UPDATE_CLIENT_UPDATE_CLIENT_H_
diff --git a/components/update_client/update_client_internal.h b/components/update_client/update_client_internal.h
deleted file mode 100644
index 94caf04..0000000
--- a/components/update_client/update_client_internal.h
+++ /dev/null
@@ -1,88 +0,0 @@
-// Copyright 2015 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.
-
-#ifndef COMPONENTS_UPDATE_CLIENT_UPDATE_CLIENT_INTERNAL_H_
-#define COMPONENTS_UPDATE_CLIENT_UPDATE_CLIENT_INTERNAL_H_
-
-#include "components/update_client/update_client.h"
-
-#include <queue>
-#include <set>
-#include <string>
-#include <vector>
-
-#include "base/macros.h"
-#include "base/observer_list.h"
-#include "base/threading/thread_checker.h"
-#include "components/update_client/crx_downloader.h"
-#include "components/update_client/update_checker.h"
-
-namespace base {
-class SequencedTaskRunner;
-class SingleThreadTaskRunner;
-}  // namespace base
-
-namespace update_client {
-
-class Configurator;
-class PingManager;
-class Task;
-struct TaskContext;
-class UpdateEngine;
-
-class UpdateClientImpl : public UpdateClient {
- public:
-  UpdateClientImpl(const scoped_refptr<Configurator>& config,
-                   scoped_ptr<PingManager> ping_manager,
-                   UpdateChecker::Factory update_checker_factory,
-                   CrxDownloader::Factory crx_downloader_factory);
-  ~UpdateClientImpl() override;
-
-  // Overrides for UpdateClient.
-  void AddObserver(Observer* observer) override;
-  void RemoveObserver(Observer* observer) override;
-  void Install(const std::string& id,
-               const CrxDataCallback& crx_data_callback,
-               const CompletionCallback& completion_callback) override;
-  void Update(const std::vector<std::string>& ids,
-              const CrxDataCallback& crx_data_callback,
-              const CompletionCallback& completion_callback) override;
-  bool GetCrxUpdateState(const std::string& id,
-                         CrxUpdateItem* update_item) const override;
-  bool IsUpdating(const std::string& id) const override;
-
- private:
-  void RunTask(Task* task, const CompletionCallback& completion_callback);
-  void OnTaskComplete(const CompletionCallback& completion_callback,
-                      Task* task,
-                      int error);
-
-  void NotifyObservers(Observer::Events event, const std::string& id);
-
-  base::ThreadChecker thread_checker_;
-
-  scoped_refptr<Configurator> config_;
-
-  // Contains the tasks that are queued up.
-  std::queue<Task*> task_queue_;
-
-  // Contains all tasks in progress.
-  std::set<Task*> tasks_;
-
-  // TODO(sorin): try to make the ping manager an observer of the service.
-  scoped_ptr<PingManager> ping_manager_;
-  scoped_ptr<UpdateEngine> update_engine_;
-
-  ObserverList<Observer> observer_list_;
-
-  // Used to post responses back to the main thread.
-  scoped_refptr<base::SingleThreadTaskRunner> main_task_runner_;
-  scoped_refptr<base::SequencedTaskRunner> blocking_task_runner_;
-
-  DISALLOW_COPY_AND_ASSIGN(UpdateClientImpl);
-};
-
-}  // namespace update_client
-
-#endif  // COMPONENTS_UPDATE_CLIENT_UPDATE_CLIENT_INTERNAL_H_
diff --git a/components/update_client/update_engine.cc b/components/update_client/update_engine.cc
deleted file mode 100644
index 4c64fde..0000000
--- a/components/update_client/update_engine.cc
+++ /dev/null
@@ -1,133 +0,0 @@
-// Copyright 2015 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_engine.h"
-
-#include "base/bind.h"
-#include "base/bind_helpers.h"
-#include "base/location.h"
-#include "base/macros.h"
-#include "base/single_thread_task_runner.h"
-#include "base/stl_util.h"
-#include "base/thread_task_runner_handle.h"
-#include "components/update_client/action_update_check.h"
-#include "components/update_client/configurator.h"
-#include "components/update_client/crx_update_item.h"
-#include "components/update_client/update_checker.h"
-
-namespace update_client {
-
-UpdateContext::UpdateContext(
-    const scoped_refptr<Configurator>& config,
-    const std::vector<std::string>& ids,
-    const UpdateClient::CrxDataCallback& crx_data_callback,
-    const UpdateEngine::NotifyObserversCallback& notify_observers_callback,
-    const UpdateEngine::CompletionCallback& callback,
-    UpdateChecker::Factory update_checker_factory,
-    CrxDownloader::Factory crx_downloader_factory,
-    PingManager* ping_manager)
-    : config(config),
-      ids(ids),
-      crx_data_callback(crx_data_callback),
-      notify_observers_callback(notify_observers_callback),
-      callback(callback),
-      main_task_runner(base::ThreadTaskRunnerHandle::Get()),
-      blocking_task_runner(config->GetSequencedTaskRunner()),
-      single_thread_task_runner(config->GetSingleThreadTaskRunner()),
-      update_checker_factory(update_checker_factory),
-      crx_downloader_factory(crx_downloader_factory),
-      ping_manager(ping_manager) {
-}
-
-UpdateContext::~UpdateContext() {
-  STLDeleteElements(&update_items);
-}
-
-UpdateEngine::UpdateEngine(
-    const scoped_refptr<Configurator>& config,
-    UpdateChecker::Factory update_checker_factory,
-    CrxDownloader::Factory crx_downloader_factory,
-    PingManager* ping_manager,
-    const NotifyObserversCallback& notify_observers_callback)
-    : config_(config),
-      update_checker_factory_(update_checker_factory),
-      crx_downloader_factory_(crx_downloader_factory),
-      ping_manager_(ping_manager),
-      notify_observers_callback_(notify_observers_callback) {
-}
-
-UpdateEngine::~UpdateEngine() {
-  DCHECK(thread_checker_.CalledOnValidThread());
-}
-
-bool UpdateEngine::IsUpdating(const std::string& id) const {
-  DCHECK(thread_checker_.CalledOnValidThread());
-  for (const auto& context : update_contexts_) {
-    const auto& ids = context->ids;
-    const auto it = std::find_if(
-        ids.begin(), ids.end(),
-        [id](const std::string& this_id) { return id == this_id; });
-    if (it != ids.end()) {
-      return true;
-    }
-  }
-  return false;
-}
-
-bool UpdateEngine::GetUpdateState(const std::string& id,
-                                  CrxUpdateItem* update_item) {
-  DCHECK(thread_checker_.CalledOnValidThread());
-  for (const auto& context : update_contexts_) {
-    const auto& update_items = context->update_items;
-    const auto it = std::find_if(update_items.begin(), update_items.end(),
-                                 [id](const CrxUpdateItem* update_item) {
-                                   return id == update_item->id;
-                                 });
-    if (it != update_items.end()) {
-      *update_item = **it;
-      return true;
-    }
-  }
-  return false;
-}
-
-void UpdateEngine::Update(
-    const std::vector<std::string>& ids,
-    const UpdateClient::CrxDataCallback& crx_data_callback,
-    const CompletionCallback& callback) {
-  DCHECK(thread_checker_.CalledOnValidThread());
-
-  scoped_ptr<UpdateContext> update_context(new UpdateContext(
-      config_, ids, crx_data_callback, notify_observers_callback_, callback,
-      update_checker_factory_, crx_downloader_factory_, ping_manager_));
-
-  CrxUpdateItem update_item;
-  scoped_ptr<ActionUpdateCheck> update_check_action(new ActionUpdateCheck(
-      (*update_context->update_checker_factory)(*config_).Pass(),
-      config_->GetBrowserVersion(), config_->ExtraRequestParams()));
-
-  update_context->current_action.reset(update_check_action.release());
-  update_contexts_.insert(update_context.get());
-
-  update_context->current_action->Run(
-      update_context.get(),
-      base::Bind(&UpdateEngine::UpdateComplete, base::Unretained(this),
-                 update_context.get()));
-
-  ignore_result(update_context.release());
-}
-
-void UpdateEngine::UpdateComplete(UpdateContext* update_context, int error) {
-  DCHECK(thread_checker_.CalledOnValidThread());
-  DCHECK(update_contexts_.find(update_context) != update_contexts_.end());
-
-  auto callback = update_context->callback;
-
-  update_contexts_.erase(update_context);
-  delete update_context;
-
-  callback.Run(error);
-}
-
-}  // namespace update_client
diff --git a/components/update_client/update_engine.h b/components/update_client/update_engine.h
deleted file mode 100644
index e902a54..0000000
--- a/components/update_client/update_engine.h
+++ /dev/null
@@ -1,149 +0,0 @@
-// Copyright 2015 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.
-
-#ifndef COMPONENTS_UPDATE_CLIENT_UPDATE_ENGINE_H_
-#define COMPONENTS_UPDATE_CLIENT_UPDATE_ENGINE_H_
-
-#include <list>
-#include <queue>
-#include <set>
-#include <string>
-#include <vector>
-
-#include "base/callback.h"
-#include "base/macros.h"
-#include "base/memory/ref_counted.h"
-#include "base/memory/scoped_ptr.h"
-#include "base/threading/thread_checker.h"
-#include "components/update_client/action.h"
-#include "components/update_client/component_patcher_operation.h"
-#include "components/update_client/component_unpacker.h"
-#include "components/update_client/crx_downloader.h"
-#include "components/update_client/crx_update_item.h"
-#include "components/update_client/ping_manager.h"
-#include "components/update_client/update_checker.h"
-#include "components/update_client/update_client.h"
-
-namespace base {
-class SequencedTaskRunner;
-class SingleThreadTaskRunner;
-}  // namespace base
-
-namespace update_client {
-
-class Configurator;
-class CrxDownloader;
-struct CrxUpdateItem;
-class PingManager;
-struct UpdateContext;
-
-// Handles updates for a group of components. Updates for different groups
-// are run concurrently but within the same group of components, updates are
-// applied one at a time.
-class UpdateEngine {
- public:
-  using CompletionCallback = base::Callback<void(int error)>;
-  using NotifyObserversCallback =
-      base::Callback<void(UpdateClient::Observer::Events event,
-                          const std::string& id)>;
-  using CrxDataCallback = UpdateClient::CrxDataCallback;
-
-  UpdateEngine(const scoped_refptr<Configurator>& config,
-               UpdateChecker::Factory update_checker_factory,
-               CrxDownloader::Factory crx_downloader_factory,
-               PingManager* ping_manager,
-               const NotifyObserversCallback& notify_observers_callback);
-  ~UpdateEngine();
-
-  // Returns true is the CRX identified by the given |id| is being updated.
-  bool IsUpdating(const std::string& id) const;
-
-  bool GetUpdateState(const std::string& id, CrxUpdateItem* update_state);
-
-  void Update(const std::vector<std::string>& ids,
-              const UpdateClient::CrxDataCallback& crx_data_callback,
-              const CompletionCallback& update_callback);
-
- private:
-  void UpdateComplete(UpdateContext* update_context, int error);
-
-  base::ThreadChecker thread_checker_;
-
-  scoped_refptr<Configurator> config_;
-
-  UpdateChecker::Factory update_checker_factory_;
-  CrxDownloader::Factory crx_downloader_factory_;
-
-  // TODO(sorin): refactor as a ref counted class.
-  PingManager* ping_manager_;  // Not owned by this class.
-
-  // Called when CRX state changes occur.
-  const NotifyObserversCallback notify_observers_callback_;
-
-  // Contains the contexts associated with each update in progress.
-  std::set<UpdateContext*> update_contexts_;
-
-  DISALLOW_COPY_AND_ASSIGN(UpdateEngine);
-};
-
-// TODO(sorin): consider making this a ref counted type.
-struct UpdateContext {
-  UpdateContext(
-      const scoped_refptr<Configurator>& config,
-      const std::vector<std::string>& ids,
-      const UpdateClient::CrxDataCallback& crx_data_callback,
-      const UpdateEngine::NotifyObserversCallback& notify_observers_callback,
-      const UpdateEngine::CompletionCallback& callback,
-      UpdateChecker::Factory update_checker_factory,
-      CrxDownloader::Factory crx_downloader_factory,
-      PingManager* ping_manager);
-
-  ~UpdateContext();
-
-  scoped_refptr<Configurator> config;
-
-  // Contains the ids of all CRXs in this context.
-  const std::vector<std::string> ids;
-
-  // Called before an update check, when update metadata is needed.
-  const UpdateEngine::CrxDataCallback& crx_data_callback;
-
-  // Called when there is a state change for any update in this context.
-  const UpdateEngine::NotifyObserversCallback notify_observers_callback;
-
-  // Called when the all updates associated with this context have completed.
-  const UpdateEngine::CompletionCallback callback;
-
-  // Posts replies back to the main thread.
-  scoped_refptr<base::SingleThreadTaskRunner> main_task_runner;
-
-  // Runs tasks in a blocking thread pool.
-  scoped_refptr<base::SequencedTaskRunner> blocking_task_runner;
-
-  // Runs tasks in the same single thread.
-  scoped_refptr<base::SingleThreadTaskRunner> single_thread_task_runner;
-
-  // Creates instances of UpdateChecker;
-  UpdateChecker::Factory update_checker_factory;
-
-  // Creates instances of CrxDownloader;
-  CrxDownloader::Factory crx_downloader_factory;
-
-  PingManager* ping_manager;  // Not owned by this class.
-
-  scoped_ptr<Action> current_action;
-
-  // TODO(sorin): use a map instead of vector.
-  std::vector<CrxUpdateItem*> update_items;
-
-  // Contains the ids of the items to update.
-  std::queue<std::string> queue;
-
-  scoped_ptr<CrxDownloader> crx_downloader;
-  scoped_refptr<ComponentUnpacker> unpacker;
-};
-
-}  // namespace update_client
-
-#endif  // COMPONENTS_UPDATE_CLIENT_UPDATE_ENGINE_H_