chromium/out/Default/gen/chrome/common/extensions/api/bookmarks.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/bookmarks.json
// by tools/json_schema_compiler.
// DO NOT EDIT.

#include "chrome/common/extensions/api/bookmarks.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 bookmarks {
//
// Properties
//

const int MAX_WRITE_OPERATIONS_PER_HOUR = …;

const int MAX_SUSTAINED_WRITE_OPERATIONS_PER_MINUTE = …;

//
// Types
//

const char* ToString(BookmarkTreeNodeUnmodifiable enum_param) { … }

BookmarkTreeNodeUnmodifiable ParseBookmarkTreeNodeUnmodifiable(std::string_view enum_string) { … }

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


BookmarkTreeNode::BookmarkTreeNode()
: … { … }

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

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

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

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

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

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


CreateDetails::CreateDetails()
 { … }

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

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

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

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

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

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



//
// Functions
//

namespace Get {

Params::IdOrIdList::IdOrIdList()
 { … }

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

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

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


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<BookmarkTreeNode>& results) { … }
}  // namespace Get

namespace GetChildren {

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<BookmarkTreeNode>& results) { … }
}  // namespace GetChildren

namespace GetRecent {

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<BookmarkTreeNode>& results) { … }
}  // namespace GetRecent

namespace GetTree {

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

namespace GetSubTree {

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<BookmarkTreeNode>& results) { … }
}  // namespace GetSubTree

namespace Search {

Params::Query::Object::Object()
 { … }

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

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

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

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

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



Params::Query::Query()
 { … }

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

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

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


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<BookmarkTreeNode>& results) { … }
}  // namespace Search

namespace Create {

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 BookmarkTreeNode& result) { … }
}  // namespace Create

namespace Move {

Params::Destination::Destination()
 { … }

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

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

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

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

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


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 BookmarkTreeNode& result) { … }
}  // namespace Move

namespace Update {

Params::Changes::Changes()
 { … }

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

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

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

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

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


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 BookmarkTreeNode& result) { … }
}  // namespace Update

namespace Remove {

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 Remove

namespace RemoveTree {

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 RemoveTree

//
// Events
//

namespace OnCreated {

const char kEventName[] = …;

base::Value::List Create(const std::string& id, const BookmarkTreeNode& bookmark) { … }

}  // namespace OnCreated

namespace OnRemoved {

const char kEventName[] = …;

RemoveInfo::RemoveInfo()
: … { … }

RemoveInfo::~RemoveInfo() = default;
RemoveInfo::RemoveInfo(RemoveInfo&& rhs) noexcept = default;
RemoveInfo& RemoveInfo::operator=(RemoveInfo&& rhs) noexcept = default;
base::Value::Dict RemoveInfo::ToValue() const { … }


base::Value::List Create(const std::string& id, const RemoveInfo& remove_info) { … }

}  // namespace OnRemoved

namespace OnChanged {

const char kEventName[] = …;

ChangeInfo::ChangeInfo()
 { … }

ChangeInfo::~ChangeInfo() = default;
ChangeInfo::ChangeInfo(ChangeInfo&& rhs) noexcept = default;
ChangeInfo& ChangeInfo::operator=(ChangeInfo&& rhs) noexcept = default;
base::Value::Dict ChangeInfo::ToValue() const { … }


base::Value::List Create(const std::string& id, const ChangeInfo& change_info) { … }

}  // namespace OnChanged

namespace OnMoved {

const char kEventName[] = …;

MoveInfo::MoveInfo()
: … { … }

MoveInfo::~MoveInfo() = default;
MoveInfo::MoveInfo(MoveInfo&& rhs) noexcept = default;
MoveInfo& MoveInfo::operator=(MoveInfo&& rhs) noexcept = default;
base::Value::Dict MoveInfo::ToValue() const { … }


base::Value::List Create(const std::string& id, const MoveInfo& move_info) { … }

}  // namespace OnMoved

namespace OnChildrenReordered {

const char kEventName[] = …;

ReorderInfo::ReorderInfo()
 { … }

ReorderInfo::~ReorderInfo() = default;
ReorderInfo::ReorderInfo(ReorderInfo&& rhs) noexcept = default;
ReorderInfo& ReorderInfo::operator=(ReorderInfo&& rhs) noexcept = default;
base::Value::Dict ReorderInfo::ToValue() const { … }


base::Value::List Create(const std::string& id, const ReorderInfo& reorder_info) { … }

}  // namespace OnChildrenReordered

namespace OnImportBegan {

const char kEventName[] = …;

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

}  // namespace OnImportBegan

namespace OnImportEnded {

const char kEventName[] = …;

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

}  // namespace OnImportEnded

}  // namespace bookmarks
}  // namespace api
}  // namespace extensions