chromium/out/Default/gen/chrome/common/extensions/api/downloads.cc

// Copyright 2024 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

// GENERATED FROM THE API DEFINITION IN
//   chrome/common/extensions/api/downloads.idl
// by tools/json_schema_compiler.
// DO NOT EDIT.

#include "chrome/common/extensions/api/downloads.h"

#include <memory>
#include <optional>
#include <ostream>
#include <string>
#include <string_view>
#include <utility>
#include <vector>

#include "base/check.h"
#include "base/check_op.h"
#include "base/notreached.h"
#include "base/strings/string_number_conversions.h"
#include "base/strings/utf_string_conversions.h"
#include "base/values.h"
#include "tools/json_schema_compiler/util.h"
#include <string_view>


UTF8ToUTF16;

namespace extensions {
namespace api {
namespace downloads {
//
// Types
//

HeaderNameValuePair::HeaderNameValuePair()
 { … }

HeaderNameValuePair::~HeaderNameValuePair() = default;
HeaderNameValuePair::HeaderNameValuePair(HeaderNameValuePair&& rhs) noexcept = default;
HeaderNameValuePair& HeaderNameValuePair::operator=(HeaderNameValuePair&& rhs) noexcept = default;
HeaderNameValuePair HeaderNameValuePair::Clone() const { … }

// static
bool HeaderNameValuePair::Populate(
    const base::Value::Dict& dict, HeaderNameValuePair& out) { … }

// static
bool HeaderNameValuePair::Populate(
    const base::Value& value, HeaderNameValuePair& out) { … }

// static
std::optional<HeaderNameValuePair> HeaderNameValuePair::FromValue(const base::Value::Dict& value) { … }

// static
std::optional<HeaderNameValuePair> HeaderNameValuePair::FromValue(const base::Value& value) { … }

base::Value::Dict HeaderNameValuePair::ToValue() const { … }


const char* ToString(FilenameConflictAction enum_param) { … }

FilenameConflictAction ParseFilenameConflictAction(std::string_view enum_string) { … }

std::u16string GetFilenameConflictActionParseError(std::string_view enum_string) { … }


FilenameSuggestion::FilenameSuggestion()
: … { … }

FilenameSuggestion::~FilenameSuggestion() = default;
FilenameSuggestion::FilenameSuggestion(FilenameSuggestion&& rhs) noexcept = default;
FilenameSuggestion& FilenameSuggestion::operator=(FilenameSuggestion&& rhs) noexcept = default;
FilenameSuggestion FilenameSuggestion::Clone() const { … }

// static
bool FilenameSuggestion::Populate(
    const base::Value::Dict& dict, FilenameSuggestion& out) { … }

// static
bool FilenameSuggestion::Populate(
    const base::Value& value, FilenameSuggestion& out) { … }

// static
std::optional<FilenameSuggestion> FilenameSuggestion::FromValue(const base::Value::Dict& value) { … }

// static
std::optional<FilenameSuggestion> FilenameSuggestion::FromValue(const base::Value& value) { … }

base::Value::Dict FilenameSuggestion::ToValue() const { … }


const char* ToString(HttpMethod enum_param) { … }

HttpMethod ParseHttpMethod(std::string_view enum_string) { … }

std::u16string GetHttpMethodParseError(std::string_view enum_string) { … }


const char* ToString(InterruptReason enum_param) { … }

InterruptReason ParseInterruptReason(std::string_view enum_string) { … }

std::u16string GetInterruptReasonParseError(std::string_view enum_string) { … }


DownloadOptions::DownloadOptions()
: … { … }

DownloadOptions::~DownloadOptions() = default;
DownloadOptions::DownloadOptions(DownloadOptions&& rhs) noexcept = default;
DownloadOptions& DownloadOptions::operator=(DownloadOptions&& rhs) noexcept = default;
DownloadOptions DownloadOptions::Clone() const { … }

// static
bool DownloadOptions::Populate(
    const base::Value::Dict& dict, DownloadOptions& out) { … }

// static
bool DownloadOptions::Populate(
    const base::Value& value, DownloadOptions& out) { … }

// static
std::optional<DownloadOptions> DownloadOptions::FromValue(const base::Value::Dict& value) { … }

// static
std::optional<DownloadOptions> DownloadOptions::FromValue(const base::Value& value) { … }

base::Value::Dict DownloadOptions::ToValue() const { … }


const char* ToString(DangerType enum_param) { … }

DangerType ParseDangerType(std::string_view enum_string) { … }

std::u16string GetDangerTypeParseError(std::string_view enum_string) { … }


const char* ToString(State enum_param) { … }

State ParseState(std::string_view enum_string) { … }

std::u16string GetStateParseError(std::string_view enum_string) { … }


DownloadItem::DownloadItem()
: … { … }

DownloadItem::~DownloadItem() = default;
DownloadItem::DownloadItem(DownloadItem&& rhs) noexcept = default;
DownloadItem& DownloadItem::operator=(DownloadItem&& rhs) noexcept = default;
DownloadItem DownloadItem::Clone() const { … }

// static
bool DownloadItem::Populate(
    const base::Value::Dict& dict, DownloadItem& out) { … }

// static
bool DownloadItem::Populate(
    const base::Value& value, DownloadItem& out) { … }

// static
std::optional<DownloadItem> DownloadItem::FromValue(const base::Value::Dict& value) { … }

// static
std::optional<DownloadItem> DownloadItem::FromValue(const base::Value& value) { … }

base::Value::Dict DownloadItem::ToValue() const { … }


DownloadQuery::DownloadQuery()
: … { … }

DownloadQuery::~DownloadQuery() = default;
DownloadQuery::DownloadQuery(DownloadQuery&& rhs) noexcept = default;
DownloadQuery& DownloadQuery::operator=(DownloadQuery&& rhs) noexcept = default;
DownloadQuery DownloadQuery::Clone() const { … }

// static
bool DownloadQuery::Populate(
    const base::Value::Dict& dict, DownloadQuery& out) { … }

// static
bool DownloadQuery::Populate(
    const base::Value& value, DownloadQuery& out) { … }

// static
std::optional<DownloadQuery> DownloadQuery::FromValue(const base::Value::Dict& value) { … }

// static
std::optional<DownloadQuery> DownloadQuery::FromValue(const base::Value& value) { … }

base::Value::Dict DownloadQuery::ToValue() const { … }


StringDelta::StringDelta()
 { … }

StringDelta::~StringDelta() = default;
StringDelta::StringDelta(StringDelta&& rhs) noexcept = default;
StringDelta& StringDelta::operator=(StringDelta&& rhs) noexcept = default;
StringDelta StringDelta::Clone() const { … }

// static
bool StringDelta::Populate(
    const base::Value::Dict& dict, StringDelta& out) { … }

// static
bool StringDelta::Populate(
    const base::Value& value, StringDelta& out) { … }

// static
std::optional<StringDelta> StringDelta::FromValue(const base::Value::Dict& value) { … }

// static
std::optional<StringDelta> StringDelta::FromValue(const base::Value& value) { … }

base::Value::Dict StringDelta::ToValue() const { … }


DoubleDelta::DoubleDelta()
 { … }

DoubleDelta::~DoubleDelta() = default;
DoubleDelta::DoubleDelta(DoubleDelta&& rhs) noexcept = default;
DoubleDelta& DoubleDelta::operator=(DoubleDelta&& rhs) noexcept = default;
DoubleDelta DoubleDelta::Clone() const { … }

// static
bool DoubleDelta::Populate(
    const base::Value::Dict& dict, DoubleDelta& out) { … }

// static
bool DoubleDelta::Populate(
    const base::Value& value, DoubleDelta& out) { … }

// static
std::optional<DoubleDelta> DoubleDelta::FromValue(const base::Value::Dict& value) { … }

// static
std::optional<DoubleDelta> DoubleDelta::FromValue(const base::Value& value) { … }

base::Value::Dict DoubleDelta::ToValue() const { … }


BooleanDelta::BooleanDelta()
 { … }

BooleanDelta::~BooleanDelta() = default;
BooleanDelta::BooleanDelta(BooleanDelta&& rhs) noexcept = default;
BooleanDelta& BooleanDelta::operator=(BooleanDelta&& rhs) noexcept = default;
BooleanDelta BooleanDelta::Clone() const { … }

// static
bool BooleanDelta::Populate(
    const base::Value::Dict& dict, BooleanDelta& out) { … }

// static
bool BooleanDelta::Populate(
    const base::Value& value, BooleanDelta& out) { … }

// static
std::optional<BooleanDelta> BooleanDelta::FromValue(const base::Value::Dict& value) { … }

// static
std::optional<BooleanDelta> BooleanDelta::FromValue(const base::Value& value) { … }

base::Value::Dict BooleanDelta::ToValue() const { … }


DownloadDelta::DownloadDelta()
: … { … }

DownloadDelta::~DownloadDelta() = default;
DownloadDelta::DownloadDelta(DownloadDelta&& rhs) noexcept = default;
DownloadDelta& DownloadDelta::operator=(DownloadDelta&& rhs) noexcept = default;
DownloadDelta DownloadDelta::Clone() const { … }

// static
bool DownloadDelta::Populate(
    const base::Value::Dict& dict, DownloadDelta& out) { … }

// static
bool DownloadDelta::Populate(
    const base::Value& value, DownloadDelta& out) { … }

// static
std::optional<DownloadDelta> DownloadDelta::FromValue(const base::Value::Dict& value) { … }

// static
std::optional<DownloadDelta> DownloadDelta::FromValue(const base::Value& value) { … }

base::Value::Dict DownloadDelta::ToValue() const { … }


GetFileIconOptions::GetFileIconOptions()
 { … }

GetFileIconOptions::~GetFileIconOptions() = default;
GetFileIconOptions::GetFileIconOptions(GetFileIconOptions&& rhs) noexcept = default;
GetFileIconOptions& GetFileIconOptions::operator=(GetFileIconOptions&& rhs) noexcept = default;
GetFileIconOptions GetFileIconOptions::Clone() const { … }

// static
bool GetFileIconOptions::Populate(
    const base::Value::Dict& dict, GetFileIconOptions& out) { … }

// static
bool GetFileIconOptions::Populate(
    const base::Value& value, GetFileIconOptions& out) { … }

// static
std::optional<GetFileIconOptions> GetFileIconOptions::FromValue(const base::Value::Dict& value) { … }

// static
std::optional<GetFileIconOptions> GetFileIconOptions::FromValue(const base::Value& value) { … }

base::Value::Dict GetFileIconOptions::ToValue() const { … }


UiOptions::UiOptions()
: … { … }

UiOptions::~UiOptions() = default;
UiOptions::UiOptions(UiOptions&& rhs) noexcept = default;
UiOptions& UiOptions::operator=(UiOptions&& rhs) noexcept = default;
UiOptions UiOptions::Clone() const { … }

// static
bool UiOptions::Populate(
    const base::Value::Dict& dict, UiOptions& out) { … }

// static
bool UiOptions::Populate(
    const base::Value& value, UiOptions& out) { … }

// static
std::optional<UiOptions> UiOptions::FromValue(const base::Value::Dict& value) { … }

// static
std::optional<UiOptions> UiOptions::FromValue(const base::Value& value) { … }

base::Value::Dict UiOptions::ToValue() const { … }



//
// Functions
//

namespace Download {

Params::Params() = default;
Params::~Params() = default;
Params::Params(Params&& rhs) noexcept = default;
Params& Params::operator=(Params&& rhs) noexcept = default;

// static
std::optional<Params> Params::Create(const base::Value::List& args) { … }


base::Value::List Results::Create(int download_id) { … }
}  // namespace Download

namespace Search {

Params::Params() = default;
Params::~Params() = default;
Params::Params(Params&& rhs) noexcept = default;
Params& Params::operator=(Params&& rhs) noexcept = default;

// static
std::optional<Params> Params::Create(const base::Value::List& args) { … }


base::Value::List Results::Create(const std::vector<DownloadItem>& results) { … }
}  // namespace Search

namespace Pause {

Params::Params() = default;
Params::~Params() = default;
Params::Params(Params&& rhs) noexcept = default;
Params& Params::operator=(Params&& rhs) noexcept = default;

// static
std::optional<Params> Params::Create(const base::Value::List& args) { … }


base::Value::List Results::Create() { … }
}  // namespace Pause

namespace Resume {

Params::Params() = default;
Params::~Params() = default;
Params::Params(Params&& rhs) noexcept = default;
Params& Params::operator=(Params&& rhs) noexcept = default;

// static
std::optional<Params> Params::Create(const base::Value::List& args) { … }


base::Value::List Results::Create() { … }
}  // namespace Resume

namespace Cancel {

Params::Params() = default;
Params::~Params() = default;
Params::Params(Params&& rhs) noexcept = default;
Params& Params::operator=(Params&& rhs) noexcept = default;

// static
std::optional<Params> Params::Create(const base::Value::List& args) { … }


base::Value::List Results::Create() { … }
}  // namespace Cancel

namespace GetFileIcon {

Params::Params() = default;
Params::~Params() = default;
Params::Params(Params&& rhs) noexcept = default;
Params& Params::operator=(Params&& rhs) noexcept = default;

// static
std::optional<Params> Params::Create(const base::Value::List& args) { … }


base::Value::List Results::Create(const std::string& icon_url) { … }
}  // namespace GetFileIcon

namespace Open {

Params::Params() = default;
Params::~Params() = default;
Params::Params(Params&& rhs) noexcept = default;
Params& Params::operator=(Params&& rhs) noexcept = default;

// static
std::optional<Params> Params::Create(const base::Value::List& args) { … }


base::Value::List Results::Create() { … }
}  // namespace Open

namespace Show {

Params::Params() = default;
Params::~Params() = default;
Params::Params(Params&& rhs) noexcept = default;
Params& Params::operator=(Params&& rhs) noexcept = default;

// static
std::optional<Params> Params::Create(const base::Value::List& args) { … }


}  // namespace Show

namespace ShowDefaultFolder {

}  // namespace ShowDefaultFolder

namespace Erase {

Params::Params() = default;
Params::~Params() = default;
Params::Params(Params&& rhs) noexcept = default;
Params& Params::operator=(Params&& rhs) noexcept = default;

// static
std::optional<Params> Params::Create(const base::Value::List& args) { … }


base::Value::List Results::Create(const std::vector<int>& erased_ids) { … }
}  // namespace Erase

namespace RemoveFile {

Params::Params() = default;
Params::~Params() = default;
Params::Params(Params&& rhs) noexcept = default;
Params& Params::operator=(Params&& rhs) noexcept = default;

// static
std::optional<Params> Params::Create(const base::Value::List& args) { … }


base::Value::List Results::Create() { … }
}  // namespace RemoveFile

namespace AcceptDanger {

Params::Params() = default;
Params::~Params() = default;
Params::Params(Params&& rhs) noexcept = default;
Params& Params::operator=(Params&& rhs) noexcept = default;

// static
std::optional<Params> Params::Create(const base::Value::List& args) { … }


base::Value::List Results::Create() { … }
}  // namespace AcceptDanger

namespace SetShelfEnabled {

Params::Params() = default;
Params::~Params() = default;
Params::Params(Params&& rhs) noexcept = default;
Params& Params::operator=(Params&& rhs) noexcept = default;

// static
std::optional<Params> Params::Create(const base::Value::List& args) { … }


}  // namespace SetShelfEnabled

namespace SetUiOptions {

Params::Params() = default;
Params::~Params() = default;
Params::Params(Params&& rhs) noexcept = default;
Params& Params::operator=(Params&& rhs) noexcept = default;

// static
std::optional<Params> Params::Create(const base::Value::List& args) { … }


base::Value::List Results::Create() { … }
}  // namespace SetUiOptions

//
// Events
//

namespace OnCreated {

const char kEventName[] = …;

base::Value::List Create(const DownloadItem& download_item) { … }

}  // namespace OnCreated

namespace OnErased {

const char kEventName[] = …;

base::Value::List Create(int download_id) { … }

}  // namespace OnErased

namespace OnChanged {

const char kEventName[] = …;

base::Value::List Create(const DownloadDelta& download_delta) { … }

}  // namespace OnChanged

namespace OnDeterminingFilename {

const char kEventName[] = …;

base::Value::List Create(const DownloadItem& download_item, base::Value::Dict suggest) { … }

}  // namespace OnDeterminingFilename

}  // namespace downloads
}  // namespace api
}  // namespace extensions