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

#include "chrome/common/extensions/api/tabs.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>
#include "extensions/common/api/extension_types.h"
#include "chrome/common/extensions/api/windows.h"


UTF8ToUTF16;

namespace extensions {
namespace api {
namespace tabs {
//
// Properties
//

const int MAX_CAPTURE_VISIBLE_TAB_CALLS_PER_SECOND = …;

const int TAB_ID_NONE = …;

const int TAB_INDEX_NONE = …;

//
// Types
//

const char* ToString(TabStatus enum_param) { … }

TabStatus ParseTabStatus(std::string_view enum_string) { … }

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


const char* ToString(MutedInfoReason enum_param) { … }

MutedInfoReason ParseMutedInfoReason(std::string_view enum_string) { … }

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


MutedInfo::MutedInfo()
: … { … }

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

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

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

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

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

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


Tab::Tab()
: … { … }

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

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

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

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

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

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


const char* ToString(ZoomSettingsMode enum_param) { … }

ZoomSettingsMode ParseZoomSettingsMode(std::string_view enum_string) { … }

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


const char* ToString(ZoomSettingsScope enum_param) { … }

ZoomSettingsScope ParseZoomSettingsScope(std::string_view enum_string) { … }

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


ZoomSettings::ZoomSettings()
: … { … }

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

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

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

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

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

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


const char* ToString(WindowType enum_param) { … }

WindowType ParseWindowType(std::string_view enum_string) { … }

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



//
// Functions
//

namespace Get {

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

namespace GetCurrent {

base::Value::List Results::Create(const Tab& tab) { … }
}  // namespace GetCurrent

namespace GetSelected {

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 Tab& tab) { … }
}  // namespace GetSelected

namespace GetAllInWindow {

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<Tab>& tabs) { … }
}  // namespace GetAllInWindow

namespace Create {

Params::CreateProperties::CreateProperties()
 { … }

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

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

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

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

// static
std::optional<Params::CreateProperties> Params::CreateProperties::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 Tab& tab) { … }
}  // namespace Create

namespace Duplicate {

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 Tab& tab) { … }
}  // namespace Duplicate

namespace Query {

Params::QueryInfo::Url::Url()
 { … }

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

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

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



Params::QueryInfo::QueryInfo()
: … { … }

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

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

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

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

// static
std::optional<Params::QueryInfo> Params::QueryInfo::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<Tab>& result) { … }
}  // namespace Query

namespace Highlight {

Params::HighlightInfo::Tabs::Tabs()
 { … }

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

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

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



Params::HighlightInfo::HighlightInfo()
 { … }

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

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

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

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

// static
std::optional<Params::HighlightInfo> Params::HighlightInfo::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 extensions::api::windows::Window& window) { … }
}  // namespace Highlight

namespace Update {

Params::UpdateProperties::UpdateProperties()
 { … }

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

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

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

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

// static
std::optional<Params::UpdateProperties> Params::UpdateProperties::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 Tab& tab) { … }
}  // namespace Update

namespace Move {

Params::TabIds::TabIds()
 { … }

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

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

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


Params::MoveProperties::MoveProperties()
: … { … }

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

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

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

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

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

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


base::Value::List Results::Create(const Tabs& tabs) { … }
}  // namespace Move

namespace Reload {

Params::ReloadProperties::ReloadProperties()
 { … }

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

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

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

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

// static
std::optional<Params::ReloadProperties> Params::ReloadProperties::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() { … }
}  // namespace Reload

namespace Remove {

Params::TabIds::TabIds()
 { … }

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

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

// static
std::optional<Params::TabIds> Params::TabIds::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() { … }
}  // namespace Remove

namespace Group {

Params::Options::TabIds::TabIds()
 { … }

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

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

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


Params::Options::CreateProperties::CreateProperties()
 { … }

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

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

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

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

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



Params::Options::Options()
 { … }

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

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

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

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

// static
std::optional<Params::Options> Params::Options::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(int group_id) { … }
}  // namespace Group

namespace Ungroup {

Params::TabIds::TabIds()
 { … }

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

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

// static
std::optional<Params::TabIds> Params::TabIds::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() { … }
}  // namespace Ungroup

namespace DetectLanguage {

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& language) { … }
}  // namespace DetectLanguage

namespace CaptureVisibleTab {

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& data_url) { … }
}  // namespace CaptureVisibleTab

namespace ExecuteScript {

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 base::Value::List& result) { … }
}  // namespace ExecuteScript

namespace InsertCSS {

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 InsertCSS

namespace RemoveCSS {

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 RemoveCSS

namespace SetZoom {

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 SetZoom

namespace GetZoom {

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(double zoom_factor) { … }
}  // namespace GetZoom

namespace SetZoomSettings {

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 SetZoomSettings

namespace GetZoomSettings {

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 ZoomSettings& zoom_settings) { … }
}  // namespace GetZoomSettings

namespace Discard {

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 Tab& tab) { … }
}  // namespace Discard

namespace GoForward {

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 GoForward

namespace GoBack {

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 GoBack

//
// Events
//

namespace OnCreated {

const char kEventName[] = …;

base::Value::List Create(const Tab& tab) { … }

}  // namespace OnCreated

namespace OnUpdated {

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(int tab_id, const ChangeInfo& change_info, const Tab& tab) { … }

}  // namespace OnUpdated

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(int tab_id, const MoveInfo& move_info) { … }

}  // namespace OnMoved

namespace OnSelectionChanged {

const char kEventName[] = …;

SelectInfo::SelectInfo()
: … { … }

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


base::Value::List Create(int tab_id, const SelectInfo& select_info) { … }

}  // namespace OnSelectionChanged

namespace OnActiveChanged {

const char kEventName[] = …;

SelectInfo::SelectInfo()
: … { … }

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


base::Value::List Create(int tab_id, const SelectInfo& select_info) { … }

}  // namespace OnActiveChanged

namespace OnActivated {

const char kEventName[] = …;

ActiveInfo::ActiveInfo()
: … { … }

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


base::Value::List Create(const ActiveInfo& active_info) { … }

}  // namespace OnActivated

namespace OnHighlightChanged {

const char kEventName[] = …;

SelectInfo::SelectInfo()
: … { … }

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


base::Value::List Create(const SelectInfo& select_info) { … }

}  // namespace OnHighlightChanged

namespace OnHighlighted {

const char kEventName[] = …;

HighlightInfo::HighlightInfo()
: … { … }

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


base::Value::List Create(const HighlightInfo& highlight_info) { … }

}  // namespace OnHighlighted

namespace OnDetached {

const char kEventName[] = …;

DetachInfo::DetachInfo()
: … { … }

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


base::Value::List Create(int tab_id, const DetachInfo& detach_info) { … }

}  // namespace OnDetached

namespace OnAttached {

const char kEventName[] = …;

AttachInfo::AttachInfo()
: … { … }

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


base::Value::List Create(int tab_id, const AttachInfo& attach_info) { … }

}  // namespace OnAttached

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(int tab_id, const RemoveInfo& remove_info) { … }

}  // namespace OnRemoved

namespace OnReplaced {

const char kEventName[] = …;

base::Value::List Create(int added_tab_id, int removed_tab_id) { … }

}  // namespace OnReplaced

namespace OnZoomChange {

const char kEventName[] = …;

ZoomChangeInfo::ZoomChangeInfo()
: … { … }

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


base::Value::List Create(const ZoomChangeInfo& zoom_change_info) { … }

}  // namespace OnZoomChange

}  // namespace tabs
}  // namespace api
}  // namespace extensions