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

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

Debuggee::Debuggee()
 { … }

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

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

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

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

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

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


DebuggerSession::DebuggerSession()
 { … }

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

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

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

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

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

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


const char* ToString(TargetInfoType enum_param) { … }

TargetInfoType ParseTargetInfoType(std::string_view enum_string) { … }

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


const char* ToString(DetachReason enum_param) { … }

DetachReason ParseDetachReason(std::string_view enum_string) { … }

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


TargetInfo::TargetInfo()
: … { … }

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

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

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

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

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

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



//
// Functions
//

namespace Attach {

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 Attach

namespace Detach {

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 Detach

namespace SendCommand {

Params::CommandParams::CommandParams()
 { … }

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

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

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

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

// static
std::optional<Params::CommandParams> Params::CommandParams::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) { … }


Results::Result::Result()
 { … }

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


base::Value::List Results::Create(const Result& result) { … }
}  // namespace SendCommand

namespace GetTargets {

base::Value::List Results::Create(const std::vector<TargetInfo>& result) { … }
}  // namespace GetTargets

//
// Events
//

namespace OnEvent {

const char kEventName[] = …;

Params::Params()
 { … }

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


base::Value::List Create(const DebuggerSession& source, const std::string& method, const Params& params) { … }

}  // namespace OnEvent

namespace OnDetach {

const char kEventName[] = …;

base::Value::List Create(const Debuggee& source, const DetachReason& reason) { … }

}  // namespace OnDetach

}  // namespace debugger
}  // namespace api
}  // namespace extensions