Consolidate the update_client serialization code.

components/update_client/component.cc

 // Copyright 2017 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/component.h"
 
 #include <algorithm>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/files/file_util.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
 #include "base/single_thread_task_runner.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "components/update_client/component_unpacker.h"
 #include "components/update_client/configurator.h"
+#include "components/update_client/protocol_builder.h"
 #include "components/update_client/update_client.h"
 #include "components/update_client/update_client_errors.h"
 #include "components/update_client/update_engine.h"
 #include "components/update_client/utils.h"
 
 // The state machine representing how a CRX component changes during an update.
 //
 //
 //                  on-demand                on-demand
 //   +--------------------------> kNew <---------------+-------------+
@@ skipping 214 matching lines @@
   base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
                                                 update_check_complete_);
 }
 
 bool Component::CanDoBackgroundDownload() const {
   // On demand component updates are always downloaded in foreground.
   return !on_demand_ && crx_component_.allows_background_download &&
          update_context_.config->EnabledBackgroundDownloader();
 }
 
-void Component::AppendDownloadMetrics(
-    const std::vector<CrxDownloader::DownloadMetrics>& download_metrics) {
-  download_metrics_.insert(download_metrics_.end(), download_metrics.begin(),
-                           download_metrics.end());
+void Component::AppendEvent(const std::string& event) {
+  events_.push_back(event);
 }
 
 void Component::NotifyObservers(UpdateClient::Observer::Events event) const {
   DCHECK(thread_checker_.CalledOnValidThread());
   update_context_.notify_observers_callback.Run(event, id_);
 }
 
 base::TimeDelta Component::GetUpdateDuration() const {
   DCHECK(thread_checker_.CalledOnValidThread());
 
@@ skipping 91 matching lines @@
     : State(component, ComponentState::kUpdateError) {}
 
 Component::StateUpdateError::~StateUpdateError() {
   DCHECK(thread_checker_.CalledOnValidThread());
 }
 
 void Component::StateUpdateError::DoHandle() {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   auto& component = State::component();
+
+  // Create an event only when the server response included an update.
+  if (component.IsUpdateAvailable())
+    component.AppendEvent(BuildUpdateCompleteEventElement(component));
+
   TransitionState(nullptr);
   component.NotifyObservers(Events::COMPONENT_NOT_UPDATED);
 }
 
 Component::StateCanUpdate::StateCanUpdate(Component* component)
     : State(component, ComponentState::kCanUpdate) {}
 
 Component::StateCanUpdate::~StateCanUpdate() {
   DCHECK(thread_checker_.CalledOnValidThread());
 }
@@ skipping 89 matching lines @@
   component().NotifyObservers(Events::COMPONENT_UPDATE_DOWNLOADING);
 }
 
 void Component::StateDownloadingDiff::DownloadComplete(
     const std::string& id,
     const CrxDownloader::Result& download_result) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   auto& component = Component::State::component();
 
-  component.AppendDownloadMetrics(crx_downloader_->download_metrics());
+  for (const auto& metrics : crx_downloader_->download_metrics())
+    component.AppendEvent(BuildDownloadCompleteEventElement(metrics));
 
   crx_downloader_.reset();
 
   if (download_result.error) {
     component.diff_error_category_ =
         static_cast<int>(ErrorCategory::kNetworkError);
     component.diff_error_code_ = download_result.error;
 
     TransitionState(base::MakeUnique<StateDownloading>(&component));
     return;
@@ skipping 45 matching lines @@
   component().NotifyObservers(Events::COMPONENT_UPDATE_DOWNLOADING);
 }
 
 void Component::StateDownloading::DownloadComplete(
     const std::string& id,
     const CrxDownloader::Result& download_result) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   auto& component = Component::State::component();
 
-  component.AppendDownloadMetrics(crx_downloader_->download_metrics());
+  for (const auto& metrics : crx_downloader_->download_metrics())
+    component.AppendEvent(BuildDownloadCompleteEventElement(metrics));
 
   crx_downloader_.reset();
 
   if (download_result.error) {
     component.error_category_ = static_cast<int>(ErrorCategory::kNetworkError);
     component.error_code_ = download_result.error;
 
     TransitionState(base::MakeUnique<StateUpdateError>(&component));
     return;
   }
@@ skipping 119 matching lines @@
   DCHECK(thread_checker_.CalledOnValidThread());
 }
 
 void Component::StateUpdated::DoHandle() {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   auto& component = State::component();
   component.crx_component_.version = component.next_version_;
   component.crx_component_.fingerprint = component.next_fp_;
 
+  component.AppendEvent(BuildUpdateCompleteEventElement(component));
+
   TransitionState(nullptr);
   component.NotifyObservers(Events::COMPONENT_UPDATED);
 }
 
 Component::StateUninstalled::StateUninstalled(Component* component)
     : State(component, ComponentState::kUninstalled) {
   DCHECK(thread_checker_.CalledOnValidThread());
 }
 
 Component::StateUninstalled::~StateUninstalled() {
   DCHECK(thread_checker_.CalledOnValidThread());
 }
 
 void Component::StateUninstalled::DoHandle() {
   DCHECK(thread_checker_.CalledOnValidThread());
+
+  auto& component = State::component();
+  component.AppendEvent(BuildUninstalledEventElement(component));
+
   TransitionState(nullptr);
 }
 
 }  // namespace update_client