components/download/database/download_db_conversions.cc - chromium/src - Git at Google

 // 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/download/database/download_db_conversions.h"

 #include <utility>
 #include "base/logging.h"
 #include "base/pickle.h"

 namespace download {

 DownloadEntry DownloadDBConversions::DownloadEntryFromProto(
     const download_pb::DownloadEntry& proto) {
   DownloadEntry entry;
   entry.guid = proto.guid();
   entry.request_origin = proto.request_origin();
   entry.download_source = DownloadSourceFromProto(proto.download_source());
   entry.ukm_download_id = proto.ukm_download_id();
   entry.bytes_wasted = proto.bytes_wasted();
   entry.fetch_error_body = proto.fetch_error_body();
   for (const auto& header : proto.request_headers()) {
     entry.request_headers.emplace_back(HttpRequestHeaderFromProto(header));
   }
   return entry;
 }

 download_pb::DownloadEntry DownloadDBConversions::DownloadEntryToProto(
     const DownloadEntry& entry) {
   download_pb::DownloadEntry proto;
   proto.set_guid(entry.guid);
   proto.set_request_origin(entry.request_origin);
   proto.set_download_source(DownloadSourceToProto(entry.download_source));
   proto.set_ukm_download_id(entry.ukm_download_id);
   proto.set_bytes_wasted(entry.bytes_wasted);
   proto.set_fetch_error_body(entry.fetch_error_body);
   for (const auto& header : entry.request_headers) {
     auto* proto_header = proto.add_request_headers();
     *proto_header = HttpRequestHeaderToProto(header);
   }
   return proto;
 }

 // static
 DownloadSource DownloadDBConversions::DownloadSourceFromProto(
     download_pb::DownloadSource download_source) {
   switch (download_source) {
     case download_pb::DownloadSource::UNKNOWN:
       return DownloadSource::UNKNOWN;
     case download_pb::DownloadSource::NAVIGATION:
       return DownloadSource::NAVIGATION;
     case download_pb::DownloadSource::DRAG_AND_DROP:
       return DownloadSource::DRAG_AND_DROP;
     case download_pb::DownloadSource::FROM_RENDERER:
       return DownloadSource::FROM_RENDERER;
     case download_pb::DownloadSource::EXTENSION_API:
       return DownloadSource::EXTENSION_API;
     case download_pb::DownloadSource::EXTENSION_INSTALLER:
       return DownloadSource::EXTENSION_INSTALLER;
     case download_pb::DownloadSource::INTERNAL_API:
       return DownloadSource::INTERNAL_API;
     case download_pb::DownloadSource::WEB_CONTENTS_API:
       return DownloadSource::WEB_CONTENTS_API;
     case download_pb::DownloadSource::OFFLINE_PAGE:
       return DownloadSource::OFFLINE_PAGE;
     case download_pb::DownloadSource::CONTEXT_MENU:
       return DownloadSource::CONTEXT_MENU;
     case download_pb::DownloadSource::RETRY:
       return DownloadSource::RETRY;
   }
   NOTREACHED();
   return DownloadSource::UNKNOWN;
 }

 // static
 download_pb::DownloadSource DownloadDBConversions::DownloadSourceToProto(
     DownloadSource download_source) {
   switch (download_source) {
     case DownloadSource::UNKNOWN:
       return download_pb::DownloadSource::UNKNOWN;
     case DownloadSource::NAVIGATION:
       return download_pb::DownloadSource::NAVIGATION;
     case DownloadSource::DRAG_AND_DROP:
       return download_pb::DownloadSource::DRAG_AND_DROP;
     case DownloadSource::FROM_RENDERER:
       return download_pb::DownloadSource::FROM_RENDERER;
     case DownloadSource::EXTENSION_API:
       return download_pb::DownloadSource::EXTENSION_API;
     case DownloadSource::EXTENSION_INSTALLER:
       return download_pb::DownloadSource::EXTENSION_INSTALLER;
     case DownloadSource::INTERNAL_API:
       return download_pb::DownloadSource::INTERNAL_API;
     case DownloadSource::WEB_CONTENTS_API:
       return download_pb::DownloadSource::WEB_CONTENTS_API;
     case DownloadSource::OFFLINE_PAGE:
       return download_pb::DownloadSource::OFFLINE_PAGE;
     case DownloadSource::CONTEXT_MENU:
       return download_pb::DownloadSource::CONTEXT_MENU;
     case DownloadSource::RETRY:
       return download_pb::DownloadSource::RETRY;
   }
   NOTREACHED();
   return download_pb::DownloadSource::UNKNOWN;
 }

 std::vector<DownloadEntry> DownloadDBConversions::DownloadEntriesFromProto(
     const download_pb::DownloadEntries& proto) {
   std::vector<DownloadEntry> entries;
   for (int i = 0; i < proto.entries_size(); i++)
     entries.push_back(DownloadEntryFromProto(proto.entries(i)));
   return entries;
 }

 download_pb::DownloadEntries DownloadDBConversions::DownloadEntriesToProto(
     const std::vector<DownloadEntry>& entries) {
   download_pb::DownloadEntries proto;
   for (size_t i = 0; i < entries.size(); i++) {
     download_pb::DownloadEntry* proto_entry = proto.add_entries();
     *proto_entry = DownloadEntryToProto(entries[i]);
   }
   return proto;
 }

 // static
 download_pb::HttpRequestHeader DownloadDBConversions::HttpRequestHeaderToProto(
     const std::pair<std::string, std::string>& header) {
   download_pb::HttpRequestHeader proto;
   if (header.first.empty())
     return proto;

   proto.set_key(header.first);
   proto.set_value(header.second);
   return proto;
 }

 // static
 std::pair<std::string, std::string>
 DownloadDBConversions::HttpRequestHeaderFromProto(
     const download_pb::HttpRequestHeader& proto) {
   if (proto.key().empty())
     return std::pair<std::string, std::string>();

   return std::make_pair(proto.key(), proto.value());
 }

 // static
 download_pb::InProgressInfo DownloadDBConversions::InProgressInfoToProto(
     const InProgressInfo& in_progress_info) {
   download_pb::InProgressInfo proto;
   for (size_t i = 0; i < in_progress_info.url_chain.size(); ++i)
     proto.add_url_chain(in_progress_info.url_chain[i].spec());
   proto.set_referrer_url(in_progress_info.referrer_url.spec());
   proto.set_site_url(in_progress_info.site_url.spec());
   proto.set_tab_url(in_progress_info.tab_url.spec());
   proto.set_tab_referrer_url(in_progress_info.tab_referrer_url.spec());
   proto.set_fetch_error_body(in_progress_info.fetch_error_body);
   for (const auto& header : in_progress_info.request_headers) {
     auto* proto_header = proto.add_request_headers();
     *proto_header = HttpRequestHeaderToProto(header);
   }
   proto.set_etag(in_progress_info.etag);
   proto.set_last_modified(in_progress_info.last_modified);
   proto.set_mime_type(in_progress_info.mime_type);
   proto.set_original_mime_type(in_progress_info.original_mime_type);
   proto.set_total_bytes(in_progress_info.total_bytes);
   base::Pickle current_path;
   in_progress_info.current_path.WriteToPickle(&current_path);
   proto.set_current_path(current_path.data(), current_path.size());
   base::Pickle target_path;
   in_progress_info.target_path.WriteToPickle(&target_path);
   proto.set_target_path(target_path.data(), target_path.size());
   proto.set_received_bytes(in_progress_info.received_bytes);
   proto.set_start_time(
       in_progress_info.start_time.is_null()
           ? -1
           : in_progress_info.start_time.ToDeltaSinceWindowsEpoch()
                 .InMilliseconds());
   proto.set_end_time(in_progress_info.end_time.is_null()
                          ? -1
                          : in_progress_info.end_time.ToDeltaSinceWindowsEpoch()
                                .InMilliseconds());
   for (size_t i = 0; i < in_progress_info.received_slices.size(); ++i) {
     download_pb::ReceivedSlice* slice = proto.add_received_slices();
     slice->set_received_bytes(
         in_progress_info.received_slices[i].received_bytes);
     slice->set_offset(in_progress_info.received_slices[i].offset);
     slice->set_finished(in_progress_info.received_slices[i].finished);
   }
   proto.set_hash(in_progress_info.hash);
   proto.set_transient(in_progress_info.transient);
   proto.set_state(in_progress_info.state);
   proto.set_danger_type(in_progress_info.danger_type);
   proto.set_interrupt_reason(in_progress_info.interrupt_reason);
   proto.set_paused(in_progress_info.paused);
   proto.set_metered(in_progress_info.metered);
   proto.set_bytes_wasted(in_progress_info.bytes_wasted);
   proto.set_auto_resume_count(in_progress_info.auto_resume_count);
   return proto;
 }

 // static
 InProgressInfo DownloadDBConversions::InProgressInfoFromProto(
     const download_pb::InProgressInfo& proto) {
   InProgressInfo info;
   for (const auto& url : proto.url_chain())
     info.url_chain.emplace_back(url);
   info.referrer_url = GURL(proto.referrer_url());
   info.site_url = GURL(proto.site_url());
   info.tab_url = GURL(proto.tab_url());
   info.tab_referrer_url = GURL(proto.tab_referrer_url());
   info.fetch_error_body = proto.fetch_error_body();
   for (const auto& header : proto.request_headers())
     info.request_headers.emplace_back(HttpRequestHeaderFromProto(header));
   info.etag = proto.etag();
   info.last_modified = proto.last_modified();
   info.mime_type = proto.mime_type();
   info.original_mime_type = proto.original_mime_type();
   info.total_bytes = proto.total_bytes();
   base::PickleIterator current_path(
       base::Pickle(proto.current_path().data(), proto.current_path().size()));
   info.current_path.ReadFromPickle(&current_path);
   base::PickleIterator target_path(
       base::Pickle(proto.target_path().data(), proto.target_path().size()));
   info.target_path.ReadFromPickle(&target_path);
   info.received_bytes = proto.received_bytes();
   info.start_time =
       proto.start_time() == -1
           ? base::Time()
           : base::Time::FromDeltaSinceWindowsEpoch(
                 base::TimeDelta::FromMilliseconds(proto.start_time()));
   info.end_time =
       proto.end_time() == -1
           ? base::Time()
           : base::Time::FromDeltaSinceWindowsEpoch(
                 base::TimeDelta::FromMilliseconds(proto.end_time()));

   for (int i = 0; i < proto.received_slices_size(); ++i) {
     info.received_slices.emplace_back(proto.received_slices(i).offset(),
                                       proto.received_slices(i).received_bytes(),
                                       proto.received_slices(i).finished());
   }
   info.hash = proto.hash();
   info.transient = proto.transient();
   info.state = static_cast<DownloadItem::DownloadState>(proto.state());
   info.danger_type = static_cast<DownloadDangerType>(proto.danger_type());
   info.interrupt_reason =
       static_cast<DownloadInterruptReason>(proto.interrupt_reason());
   info.paused = proto.paused();
   info.metered = proto.metered();
   info.bytes_wasted = proto.bytes_wasted();
   info.auto_resume_count = proto.auto_resume_count();
   return info;
 }

 UkmInfo DownloadDBConversions::UkmInfoFromProto(
     const download_pb::UkmInfo& proto) {
   UkmInfo info;
   info.download_source = DownloadSourceFromProto(proto.download_source());
   info.ukm_download_id = proto.ukm_download_id();
   return info;
 }

 download_pb::UkmInfo DownloadDBConversions::UkmInfoToProto(
     const UkmInfo& info) {
   download_pb::UkmInfo proto;
   proto.set_download_source(DownloadSourceToProto(info.download_source));
   proto.set_ukm_download_id(info.ukm_download_id);
   return proto;
 }

 DownloadInfo DownloadDBConversions::DownloadInfoFromProto(
     const download_pb::DownloadInfo& proto) {
   DownloadInfo info;
   info.guid = proto.guid();
   info.id = proto.id();
   if (proto.has_ukm_info())
     info.ukm_info = UkmInfoFromProto(proto.ukm_info());
   if (proto.has_in_progress_info())
     info.in_progress_info = InProgressInfoFromProto(proto.in_progress_info());
   return info;
 }

 download_pb::DownloadInfo DownloadDBConversions::DownloadInfoToProto(
     const DownloadInfo& info) {
   download_pb::DownloadInfo proto;
   proto.set_guid(info.guid);
   proto.set_id(info.id);
   if (info.ukm_info.has_value()) {
     auto ukm_info = std::make_unique<download_pb::UkmInfo>(
         UkmInfoToProto(info.ukm_info.value()));
     proto.set_allocated_ukm_info(ukm_info.release());
   }
   if (info.in_progress_info.has_value()) {
     auto in_progress_info = std::make_unique<download_pb::InProgressInfo>(
         InProgressInfoToProto(info.in_progress_info.value()));
     proto.set_allocated_in_progress_info(in_progress_info.release());
   }
   return proto;
 }

 DownloadDBEntry DownloadDBConversions::DownloadDBEntryFromProto(
     const download_pb::DownloadDBEntry& proto) {
   DownloadDBEntry entry;
   if (proto.has_download_info())
     entry.download_info = DownloadInfoFromProto(proto.download_info());
   return entry;
 }

 download_pb::DownloadDBEntry DownloadDBConversions::DownloadDBEntryToProto(
     const DownloadDBEntry& info) {
   download_pb::DownloadDBEntry proto;
   if (info.download_info.has_value()) {
     auto download_info = std::make_unique<download_pb::DownloadInfo>(
         DownloadInfoToProto(info.download_info.value()));
     proto.set_allocated_download_info(download_info.release());
   }
   return proto;
 }

 DownloadDBEntry DownloadDBConversions::DownloadDBEntryFromDownloadEntry(
     const DownloadEntry& entry) {
   DownloadDBEntry db_entry;
   DownloadInfo download_info;
   download_info.guid = entry.guid;

   UkmInfo ukm_info(entry.download_source, entry.ukm_download_id);

   InProgressInfo in_progress_info;
   in_progress_info.fetch_error_body = entry.fetch_error_body;
   in_progress_info.request_headers = entry.request_headers;

   download_info.ukm_info = ukm_info;
   download_info.in_progress_info = in_progress_info;
   db_entry.download_info = download_info;
   return db_entry;
 }

 }  // namespace download
	// 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/download/database/download_db_conversions.h"

	#include <utility>
	#include "base/logging.h"
	#include "base/pickle.h"

	namespace download {

	DownloadEntry DownloadDBConversions::DownloadEntryFromProto(
	const download_pb::DownloadEntry& proto) {
	DownloadEntry entry;
	entry.guid = proto.guid();
	entry.request_origin = proto.request_origin();
	entry.download_source = DownloadSourceFromProto(proto.download_source());
	entry.ukm_download_id = proto.ukm_download_id();
	entry.bytes_wasted = proto.bytes_wasted();
	entry.fetch_error_body = proto.fetch_error_body();
	for (const auto& header : proto.request_headers()) {
	entry.request_headers.emplace_back(HttpRequestHeaderFromProto(header));
	}
	return entry;
	}

	download_pb::DownloadEntry DownloadDBConversions::DownloadEntryToProto(
	const DownloadEntry& entry) {
	download_pb::DownloadEntry proto;
	proto.set_guid(entry.guid);
	proto.set_request_origin(entry.request_origin);
	proto.set_download_source(DownloadSourceToProto(entry.download_source));
	proto.set_ukm_download_id(entry.ukm_download_id);
	proto.set_bytes_wasted(entry.bytes_wasted);
	proto.set_fetch_error_body(entry.fetch_error_body);
	for (const auto& header : entry.request_headers) {
	auto* proto_header = proto.add_request_headers();
	*proto_header = HttpRequestHeaderToProto(header);
	}
	return proto;
	}

	// static
	DownloadSource DownloadDBConversions::DownloadSourceFromProto(
	download_pb::DownloadSource download_source) {
	switch (download_source) {
	case download_pb::DownloadSource::UNKNOWN:
	return DownloadSource::UNKNOWN;
	case download_pb::DownloadSource::NAVIGATION:
	return DownloadSource::NAVIGATION;
	case download_pb::DownloadSource::DRAG_AND_DROP:
	return DownloadSource::DRAG_AND_DROP;
	case download_pb::DownloadSource::FROM_RENDERER:
	return DownloadSource::FROM_RENDERER;
	case download_pb::DownloadSource::EXTENSION_API:
	return DownloadSource::EXTENSION_API;
	case download_pb::DownloadSource::EXTENSION_INSTALLER:
	return DownloadSource::EXTENSION_INSTALLER;
	case download_pb::DownloadSource::INTERNAL_API:
	return DownloadSource::INTERNAL_API;
	case download_pb::DownloadSource::WEB_CONTENTS_API:
	return DownloadSource::WEB_CONTENTS_API;
	case download_pb::DownloadSource::OFFLINE_PAGE:
	return DownloadSource::OFFLINE_PAGE;
	case download_pb::DownloadSource::CONTEXT_MENU:
	return DownloadSource::CONTEXT_MENU;
	case download_pb::DownloadSource::RETRY:
	return DownloadSource::RETRY;
	}
	NOTREACHED();
	return DownloadSource::UNKNOWN;
	}

	// static
	download_pb::DownloadSource DownloadDBConversions::DownloadSourceToProto(
	DownloadSource download_source) {
	switch (download_source) {
	case DownloadSource::UNKNOWN:
	return download_pb::DownloadSource::UNKNOWN;
	case DownloadSource::NAVIGATION:
	return download_pb::DownloadSource::NAVIGATION;
	case DownloadSource::DRAG_AND_DROP:
	return download_pb::DownloadSource::DRAG_AND_DROP;
	case DownloadSource::FROM_RENDERER:
	return download_pb::DownloadSource::FROM_RENDERER;
	case DownloadSource::EXTENSION_API:
	return download_pb::DownloadSource::EXTENSION_API;
	case DownloadSource::EXTENSION_INSTALLER:
	return download_pb::DownloadSource::EXTENSION_INSTALLER;
	case DownloadSource::INTERNAL_API:
	return download_pb::DownloadSource::INTERNAL_API;
	case DownloadSource::WEB_CONTENTS_API:
	return download_pb::DownloadSource::WEB_CONTENTS_API;
	case DownloadSource::OFFLINE_PAGE:
	return download_pb::DownloadSource::OFFLINE_PAGE;
	case DownloadSource::CONTEXT_MENU:
	return download_pb::DownloadSource::CONTEXT_MENU;
	case DownloadSource::RETRY:
	return download_pb::DownloadSource::RETRY;
	}
	NOTREACHED();
	return download_pb::DownloadSource::UNKNOWN;
	}

	std::vector<DownloadEntry> DownloadDBConversions::DownloadEntriesFromProto(
	const download_pb::DownloadEntries& proto) {
	std::vector<DownloadEntry> entries;
	for (int i = 0; i < proto.entries_size(); i++)
	entries.push_back(DownloadEntryFromProto(proto.entries(i)));
	return entries;
	}

	download_pb::DownloadEntries DownloadDBConversions::DownloadEntriesToProto(
	const std::vector<DownloadEntry>& entries) {
	download_pb::DownloadEntries proto;
	for (size_t i = 0; i < entries.size(); i++) {
	download_pb::DownloadEntry* proto_entry = proto.add_entries();
	*proto_entry = DownloadEntryToProto(entries[i]);
	}
	return proto;
	}

	// static
	download_pb::HttpRequestHeader DownloadDBConversions::HttpRequestHeaderToProto(
	const std::pair<std::string, std::string>& header) {
	download_pb::HttpRequestHeader proto;
	if (header.first.empty())
	return proto;

	proto.set_key(header.first);
	proto.set_value(header.second);
	return proto;
	}

	// static
	std::pair<std::string, std::string>
	DownloadDBConversions::HttpRequestHeaderFromProto(
	const download_pb::HttpRequestHeader& proto) {
	if (proto.key().empty())
	return std::pair<std::string, std::string>();

	return std::make_pair(proto.key(), proto.value());
	}

	// static
	download_pb::InProgressInfo DownloadDBConversions::InProgressInfoToProto(
	const InProgressInfo& in_progress_info) {
	download_pb::InProgressInfo proto;
	for (size_t i = 0; i < in_progress_info.url_chain.size(); ++i)
	proto.add_url_chain(in_progress_info.url_chain[i].spec());
	proto.set_referrer_url(in_progress_info.referrer_url.spec());
	proto.set_site_url(in_progress_info.site_url.spec());
	proto.set_tab_url(in_progress_info.tab_url.spec());
	proto.set_tab_referrer_url(in_progress_info.tab_referrer_url.spec());
	proto.set_fetch_error_body(in_progress_info.fetch_error_body);
	for (const auto& header : in_progress_info.request_headers) {
	auto* proto_header = proto.add_request_headers();
	*proto_header = HttpRequestHeaderToProto(header);
	}
	proto.set_etag(in_progress_info.etag);
	proto.set_last_modified(in_progress_info.last_modified);
	proto.set_mime_type(in_progress_info.mime_type);
	proto.set_original_mime_type(in_progress_info.original_mime_type);
	proto.set_total_bytes(in_progress_info.total_bytes);
	base::Pickle current_path;
	in_progress_info.current_path.WriteToPickle(&current_path);
	proto.set_current_path(current_path.data(), current_path.size());
	base::Pickle target_path;
	in_progress_info.target_path.WriteToPickle(&target_path);
	proto.set_target_path(target_path.data(), target_path.size());
	proto.set_received_bytes(in_progress_info.received_bytes);
	proto.set_start_time(
	in_progress_info.start_time.is_null()
	? -1
	: in_progress_info.start_time.ToDeltaSinceWindowsEpoch()
	.InMilliseconds());
	proto.set_end_time(in_progress_info.end_time.is_null()
	? -1
	: in_progress_info.end_time.ToDeltaSinceWindowsEpoch()
	.InMilliseconds());
	for (size_t i = 0; i < in_progress_info.received_slices.size(); ++i) {
	download_pb::ReceivedSlice* slice = proto.add_received_slices();
	slice->set_received_bytes(
	in_progress_info.received_slices[i].received_bytes);
	slice->set_offset(in_progress_info.received_slices[i].offset);
	slice->set_finished(in_progress_info.received_slices[i].finished);
	}
	proto.set_hash(in_progress_info.hash);
	proto.set_transient(in_progress_info.transient);
	proto.set_state(in_progress_info.state);
	proto.set_danger_type(in_progress_info.danger_type);
	proto.set_interrupt_reason(in_progress_info.interrupt_reason);
	proto.set_paused(in_progress_info.paused);
	proto.set_metered(in_progress_info.metered);
	proto.set_bytes_wasted(in_progress_info.bytes_wasted);
	proto.set_auto_resume_count(in_progress_info.auto_resume_count);
	return proto;
	}

	// static
	InProgressInfo DownloadDBConversions::InProgressInfoFromProto(
	const download_pb::InProgressInfo& proto) {
	InProgressInfo info;
	for (const auto& url : proto.url_chain())
	info.url_chain.emplace_back(url);
	info.referrer_url = GURL(proto.referrer_url());
	info.site_url = GURL(proto.site_url());
	info.tab_url = GURL(proto.tab_url());
	info.tab_referrer_url = GURL(proto.tab_referrer_url());
	info.fetch_error_body = proto.fetch_error_body();
	for (const auto& header : proto.request_headers())
	info.request_headers.emplace_back(HttpRequestHeaderFromProto(header));
	info.etag = proto.etag();
	info.last_modified = proto.last_modified();
	info.mime_type = proto.mime_type();
	info.original_mime_type = proto.original_mime_type();
	info.total_bytes = proto.total_bytes();
	base::PickleIterator current_path(
	base::Pickle(proto.current_path().data(), proto.current_path().size()));
	info.current_path.ReadFromPickle(&current_path);
	base::PickleIterator target_path(
	base::Pickle(proto.target_path().data(), proto.target_path().size()));
	info.target_path.ReadFromPickle(&target_path);
	info.received_bytes = proto.received_bytes();
	info.start_time =
	proto.start_time() == -1
	? base::Time()
	: base::Time::FromDeltaSinceWindowsEpoch(
	base::TimeDelta::FromMilliseconds(proto.start_time()));
	info.end_time =
	proto.end_time() == -1
	? base::Time()
	: base::Time::FromDeltaSinceWindowsEpoch(
	base::TimeDelta::FromMilliseconds(proto.end_time()));

	for (int i = 0; i < proto.received_slices_size(); ++i) {
	info.received_slices.emplace_back(proto.received_slices(i).offset(),
	proto.received_slices(i).received_bytes(),
	proto.received_slices(i).finished());
	}
	info.hash = proto.hash();
	info.transient = proto.transient();
	info.state = static_cast<DownloadItem::DownloadState>(proto.state());
	info.danger_type = static_cast<DownloadDangerType>(proto.danger_type());
	info.interrupt_reason =
	static_cast<DownloadInterruptReason>(proto.interrupt_reason());
	info.paused = proto.paused();
	info.metered = proto.metered();
	info.bytes_wasted = proto.bytes_wasted();
	info.auto_resume_count = proto.auto_resume_count();
	return info;
	}

	UkmInfo DownloadDBConversions::UkmInfoFromProto(
	const download_pb::UkmInfo& proto) {
	UkmInfo info;
	info.download_source = DownloadSourceFromProto(proto.download_source());
	info.ukm_download_id = proto.ukm_download_id();
	return info;
	}

	download_pb::UkmInfo DownloadDBConversions::UkmInfoToProto(
	const UkmInfo& info) {
	download_pb::UkmInfo proto;
	proto.set_download_source(DownloadSourceToProto(info.download_source));
	proto.set_ukm_download_id(info.ukm_download_id);
	return proto;
	}

	DownloadInfo DownloadDBConversions::DownloadInfoFromProto(
	const download_pb::DownloadInfo& proto) {
	DownloadInfo info;
	info.guid = proto.guid();
	info.id = proto.id();
	if (proto.has_ukm_info())
	info.ukm_info = UkmInfoFromProto(proto.ukm_info());
	if (proto.has_in_progress_info())
	info.in_progress_info = InProgressInfoFromProto(proto.in_progress_info());
	return info;
	}

	download_pb::DownloadInfo DownloadDBConversions::DownloadInfoToProto(
	const DownloadInfo& info) {
	download_pb::DownloadInfo proto;
	proto.set_guid(info.guid);
	proto.set_id(info.id);
	if (info.ukm_info.has_value()) {
	auto ukm_info = std::make_unique<download_pb::UkmInfo>(
	UkmInfoToProto(info.ukm_info.value()));
	proto.set_allocated_ukm_info(ukm_info.release());
	}
	if (info.in_progress_info.has_value()) {
	auto in_progress_info = std::make_unique<download_pb::InProgressInfo>(
	InProgressInfoToProto(info.in_progress_info.value()));
	proto.set_allocated_in_progress_info(in_progress_info.release());
	}
	return proto;
	}

	DownloadDBEntry DownloadDBConversions::DownloadDBEntryFromProto(
	const download_pb::DownloadDBEntry& proto) {
	DownloadDBEntry entry;
	if (proto.has_download_info())
	entry.download_info = DownloadInfoFromProto(proto.download_info());
	return entry;
	}

	download_pb::DownloadDBEntry DownloadDBConversions::DownloadDBEntryToProto(
	const DownloadDBEntry& info) {
	download_pb::DownloadDBEntry proto;
	if (info.download_info.has_value()) {
	auto download_info = std::make_unique<download_pb::DownloadInfo>(
	DownloadInfoToProto(info.download_info.value()));
	proto.set_allocated_download_info(download_info.release());
	}
	return proto;
	}

	DownloadDBEntry DownloadDBConversions::DownloadDBEntryFromDownloadEntry(
	const DownloadEntry& entry) {
	DownloadDBEntry db_entry;
	DownloadInfo download_info;
	download_info.guid = entry.guid;

	UkmInfo ukm_info(entry.download_source, entry.ukm_download_id);

	InProgressInfo in_progress_info;
	in_progress_info.fetch_error_body = entry.fetch_error_body;
	in_progress_info.request_headers = entry.request_headers;

	download_info.ukm_info = ukm_info;
	download_info.in_progress_info = in_progress_info;
	db_entry.download_info = download_info;
	return db_entry;
	}

	} // namespace download