system_display.cc | Explore in Territory

// 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
//   extensions/common/api/system_display.idl
// by tools/json_schema_compiler.
// DO NOT EDIT.

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

Bounds::Bounds()
: … { … }

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

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

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

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

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

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


Insets::Insets()
: … { … }

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

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

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

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

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

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


Point::Point()
: … { … }

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

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

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

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

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

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


TouchCalibrationPair::TouchCalibrationPair()
 { … }

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

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

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

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

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

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


TouchCalibrationPairQuad::TouchCalibrationPairQuad()
 { … }

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

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

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

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

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

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


DisplayMode::DisplayMode()
: … { … }

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

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

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

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

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

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


const char* ToString(LayoutPosition enum_param) { … }

LayoutPosition ParseLayoutPosition(std::string_view enum_string) { … }

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


DisplayLayout::DisplayLayout()
: … { … }

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

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

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

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

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

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


Edid::Edid()
: … { … }

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

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

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

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

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

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


const char* ToString(ActiveState enum_param) { … }

ActiveState ParseActiveState(std::string_view enum_string) { … }

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


DisplayUnitInfo::DisplayUnitInfo()
: … { … }

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

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

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

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

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

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


DisplayProperties::DisplayProperties()
 { … }

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

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

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

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

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

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


GetInfoFlags::GetInfoFlags()
 { … }

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

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

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

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

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

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


const char* ToString(MirrorMode enum_param) { … }

MirrorMode ParseMirrorMode(std::string_view enum_string) { … }

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


MirrorModeInfo::MirrorModeInfo()
: … { … }

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

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

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

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

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

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



//
// Functions
//

namespace GetInfo {

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<DisplayUnitInfo>& display_info) { … }
}  // namespace GetInfo

namespace GetDisplayLayout {

base::Value::List Results::Create(const std::vector<DisplayLayout>& layouts) { … }
}  // namespace GetDisplayLayout

namespace SetDisplayProperties {

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 SetDisplayProperties

namespace SetDisplayLayout {

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 SetDisplayLayout

namespace EnableUnifiedDesktop {

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 EnableUnifiedDesktop

namespace OverscanCalibrationStart {

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 OverscanCalibrationStart

namespace OverscanCalibrationAdjust {

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 OverscanCalibrationAdjust

namespace OverscanCalibrationReset {

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 OverscanCalibrationReset

namespace OverscanCalibrationComplete {

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 OverscanCalibrationComplete

namespace ShowNativeTouchCalibration {

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(bool success) { … }
}  // namespace ShowNativeTouchCalibration

namespace StartCustomTouchCalibration {

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 StartCustomTouchCalibration

namespace CompleteCustomTouchCalibration {

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 CompleteCustomTouchCalibration

namespace ClearTouchCalibration {

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 ClearTouchCalibration

namespace SetMirrorMode {

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 SetMirrorMode

//
// Events
//

namespace OnDisplayChanged {

const char kEventName[] = …;

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

}  // namespace OnDisplayChanged

}  // namespace system_display
}  // namespace api
}  // namespace extensions
chromium/out/Default/gen/extensions/common/api/system_display.cc
