| // camera/mojo/camera_diagnostics.mojom-shared.h is auto generated by mojom_bindings_generator.py, do not edit |
| |
| // Copyright 2016 The Chromium Authors |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #ifndef CAMERA_MOJO_CAMERA_DIAGNOSTICS_MOJOM_SHARED_H_ |
| #define CAMERA_MOJO_CAMERA_DIAGNOSTICS_MOJOM_SHARED_H_ |
| |
| #include <stdint.h> |
| |
| #include <functional> |
| #include <iosfwd> |
| #include <type_traits> |
| #include <utility> |
| #include "mojo/public/cpp/bindings/array_data_view.h" |
| #include "mojo/public/cpp/bindings/enum_traits.h" |
| #include "mojo/public/cpp/bindings/interface_data_view.h" |
| #include "mojo/public/cpp/bindings/lib/bindings_internal.h" |
| #include "mojo/public/cpp/bindings/lib/serialization.h" |
| #include "mojo/public/cpp/bindings/map_data_view.h" |
| #include "mojo/public/cpp/bindings/string_data_view.h" |
| |
| #include "third_party/perfetto/include/perfetto/tracing/traced_value_forward.h" |
| |
| #include "camera/mojo/camera_diagnostics.mojom-shared-internal.h" |
| #include "mojo/public/cpp/bindings/lib/interface_serialization.h" |
| #include "mojo/public/cpp/system/data_pipe.h" |
| |
| |
| |
| |
| |
| |
| namespace cros::camera_diag::mojom { |
| class AnalyzerResultDataView; |
| |
| class DiagnosticsResultDataView; |
| |
| class FrameAnalysisConfigDataView; |
| |
| class CameraFrameBufferDataView; |
| |
| class CameraStreamDataView; |
| |
| class CameraFrameDataView; |
| |
| class StreamingConfigDataView; |
| |
| class FrameAnalysisResultDataView; |
| class StartStreamingResultDataView; |
| |
| |
| } // cros::camera_diag::mojom |
| |
| namespace mojo { |
| namespace internal { |
| |
| template <> |
| struct MojomTypeTraits<::cros::camera_diag::mojom::AnalyzerResultDataView> { |
| using Data = ::cros::camera_diag::mojom::internal::AnalyzerResult_Data; |
| using DataAsArrayElement = Pointer<Data>; |
| static constexpr MojomTypeCategory category = MojomTypeCategory::kStruct; |
| }; |
| |
| template <> |
| struct MojomTypeTraits<::cros::camera_diag::mojom::DiagnosticsResultDataView> { |
| using Data = ::cros::camera_diag::mojom::internal::DiagnosticsResult_Data; |
| using DataAsArrayElement = Pointer<Data>; |
| static constexpr MojomTypeCategory category = MojomTypeCategory::kStruct; |
| }; |
| |
| template <> |
| struct MojomTypeTraits<::cros::camera_diag::mojom::FrameAnalysisConfigDataView> { |
| using Data = ::cros::camera_diag::mojom::internal::FrameAnalysisConfig_Data; |
| using DataAsArrayElement = Pointer<Data>; |
| static constexpr MojomTypeCategory category = MojomTypeCategory::kStruct; |
| }; |
| |
| template <> |
| struct MojomTypeTraits<::cros::camera_diag::mojom::CameraFrameBufferDataView> { |
| using Data = ::cros::camera_diag::mojom::internal::CameraFrameBuffer_Data; |
| using DataAsArrayElement = Pointer<Data>; |
| static constexpr MojomTypeCategory category = MojomTypeCategory::kStruct; |
| }; |
| |
| template <> |
| struct MojomTypeTraits<::cros::camera_diag::mojom::CameraStreamDataView> { |
| using Data = ::cros::camera_diag::mojom::internal::CameraStream_Data; |
| using DataAsArrayElement = Pointer<Data>; |
| static constexpr MojomTypeCategory category = MojomTypeCategory::kStruct; |
| }; |
| |
| template <> |
| struct MojomTypeTraits<::cros::camera_diag::mojom::CameraFrameDataView> { |
| using Data = ::cros::camera_diag::mojom::internal::CameraFrame_Data; |
| using DataAsArrayElement = Pointer<Data>; |
| static constexpr MojomTypeCategory category = MojomTypeCategory::kStruct; |
| }; |
| |
| template <> |
| struct MojomTypeTraits<::cros::camera_diag::mojom::StreamingConfigDataView> { |
| using Data = ::cros::camera_diag::mojom::internal::StreamingConfig_Data; |
| using DataAsArrayElement = Pointer<Data>; |
| static constexpr MojomTypeCategory category = MojomTypeCategory::kStruct; |
| }; |
| |
| template <> |
| struct MojomTypeTraits<::cros::camera_diag::mojom::FrameAnalysisResultDataView> { |
| using Data = ::cros::camera_diag::mojom::internal::FrameAnalysisResult_Data; |
| using DataAsArrayElement = Data; |
| static constexpr MojomTypeCategory category = MojomTypeCategory::kUnion; |
| }; |
| |
| template <> |
| struct MojomTypeTraits<::cros::camera_diag::mojom::StartStreamingResultDataView> { |
| using Data = ::cros::camera_diag::mojom::internal::StartStreamingResult_Data; |
| using DataAsArrayElement = Data; |
| static constexpr MojomTypeCategory category = MojomTypeCategory::kUnion; |
| }; |
| |
| } // namespace internal |
| } // namespace mojo |
| |
| |
| namespace cros::camera_diag::mojom { |
| |
| |
| enum class AnalyzerStatus : int32_t { |
| |
| kNotRun = 0, |
| |
| kPassed = 1, |
| |
| kFailed = 2, |
| kMinValue = 0, |
| kMaxValue = 2, |
| }; |
| |
| std::ostream& operator<<(std::ostream& os, AnalyzerStatus value); |
| inline bool IsKnownEnumValue(AnalyzerStatus value) { |
| return internal::AnalyzerStatus_Data::IsKnownValue( |
| static_cast<int32_t>(value)); |
| } |
| |
| |
| enum class AnalyzerType : int32_t { |
| |
| kUnknown = 0, |
| |
| kPrivacyShutterSwTest = 1, |
| |
| kDirtyLens = 2, |
| kMinValue = 0, |
| kMaxValue = 2, |
| kDefaultValue = 0 |
| }; |
| |
| std::ostream& operator<<(std::ostream& os, AnalyzerType value); |
| inline bool IsKnownEnumValue(AnalyzerType value) { |
| return internal::AnalyzerType_Data::IsKnownValue( |
| static_cast<int32_t>(value)); |
| } |
| inline AnalyzerType ToKnownEnumValue(AnalyzerType value) { |
| if (IsKnownEnumValue(value)) { |
| return value; |
| } |
| return AnalyzerType::kDefaultValue; |
| } |
| |
| |
| enum class CameraIssue : int32_t { |
| |
| kNone = 0, |
| |
| kManufacturerIssue = 1, |
| |
| kPrivacyShutterOn = 2, |
| |
| kDirtyLens = 3, |
| |
| kCameraServiceDown = 4, |
| kMinValue = 0, |
| kMaxValue = 4, |
| kDefaultValue = 0 |
| }; |
| |
| std::ostream& operator<<(std::ostream& os, CameraIssue value); |
| inline bool IsKnownEnumValue(CameraIssue value) { |
| return internal::CameraIssue_Data::IsKnownValue( |
| static_cast<int32_t>(value)); |
| } |
| inline CameraIssue ToKnownEnumValue(CameraIssue value) { |
| if (IsKnownEnumValue(value)) { |
| return value; |
| } |
| return CameraIssue::kDefaultValue; |
| } |
| |
| |
| enum class ClientType : int32_t { |
| |
| kUnknown = 0, |
| |
| kHealthd = 1, |
| |
| kCca = 2, |
| kMinValue = 0, |
| kMaxValue = 2, |
| kDefaultValue = 0 |
| }; |
| |
| std::ostream& operator<<(std::ostream& os, ClientType value); |
| inline bool IsKnownEnumValue(ClientType value) { |
| return internal::ClientType_Data::IsKnownValue( |
| static_cast<int32_t>(value)); |
| } |
| inline ClientType ToKnownEnumValue(ClientType value) { |
| if (IsKnownEnumValue(value)) { |
| return value; |
| } |
| return ClientType::kDefaultValue; |
| } |
| |
| |
| enum class DataSource : int32_t { |
| |
| kChrome = 0, |
| |
| kCameraService = 1, |
| |
| kClientApp = 2, |
| |
| kCameraDiagnostics = 3, |
| kMinValue = 0, |
| kMaxValue = 3, |
| kDefaultValue = 0 |
| }; |
| |
| std::ostream& operator<<(std::ostream& os, DataSource value); |
| inline bool IsKnownEnumValue(DataSource value) { |
| return internal::DataSource_Data::IsKnownValue( |
| static_cast<int32_t>(value)); |
| } |
| inline DataSource ToKnownEnumValue(DataSource value) { |
| if (IsKnownEnumValue(value)) { |
| return value; |
| } |
| return DataSource::kDefaultValue; |
| } |
| |
| |
| enum class ErrorCode : int32_t { |
| |
| kUnknown = 0, |
| |
| kCameraClosed = 1, |
| |
| kMultipleOpenCameras = 2, |
| |
| kAlreadyRunningAnalysis = 3, |
| |
| kNotEnoughFrames = 4, |
| |
| kInvalidDuration = 5, |
| |
| kCrosCameraControllerNotRegistered = 6, |
| |
| kDiagnosticsInternal = 7, |
| kMinValue = 0, |
| kMaxValue = 7, |
| kDefaultValue = 0 |
| }; |
| |
| std::ostream& operator<<(std::ostream& os, ErrorCode value); |
| inline bool IsKnownEnumValue(ErrorCode value) { |
| return internal::ErrorCode_Data::IsKnownValue( |
| static_cast<int32_t>(value)); |
| } |
| inline ErrorCode ToKnownEnumValue(ErrorCode value) { |
| if (IsKnownEnumValue(value)) { |
| return value; |
| } |
| return ErrorCode::kDefaultValue; |
| } |
| |
| |
| enum class PixelFormat : int32_t { |
| |
| kYuv420 = 0, |
| |
| kJpeg = 1, |
| kMinValue = 0, |
| kMaxValue = 1, |
| kDefaultValue = 0 |
| }; |
| |
| std::ostream& operator<<(std::ostream& os, PixelFormat value); |
| inline bool IsKnownEnumValue(PixelFormat value) { |
| return internal::PixelFormat_Data::IsKnownValue( |
| static_cast<int32_t>(value)); |
| } |
| inline PixelFormat ToKnownEnumValue(PixelFormat value) { |
| if (IsKnownEnumValue(value)) { |
| return value; |
| } |
| return PixelFormat::kDefaultValue; |
| } |
| // Interface base classes. They are used for type safety check. |
| class CameraDiagnosticsInterfaceBase {}; |
| |
| using CameraDiagnosticsPtrDataView = |
| mojo::InterfacePtrDataView<CameraDiagnosticsInterfaceBase>; |
| using CameraDiagnosticsRequestDataView = |
| mojo::InterfaceRequestDataView<CameraDiagnosticsInterfaceBase>; |
| using CameraDiagnosticsAssociatedPtrInfoDataView = |
| mojo::AssociatedInterfacePtrInfoDataView<CameraDiagnosticsInterfaceBase>; |
| using CameraDiagnosticsAssociatedRequestDataView = |
| mojo::AssociatedInterfaceRequestDataView<CameraDiagnosticsInterfaceBase>; |
| class CrosCameraDiagnosticsServiceInterfaceBase {}; |
| |
| using CrosCameraDiagnosticsServicePtrDataView = |
| mojo::InterfacePtrDataView<CrosCameraDiagnosticsServiceInterfaceBase>; |
| using CrosCameraDiagnosticsServiceRequestDataView = |
| mojo::InterfaceRequestDataView<CrosCameraDiagnosticsServiceInterfaceBase>; |
| using CrosCameraDiagnosticsServiceAssociatedPtrInfoDataView = |
| mojo::AssociatedInterfacePtrInfoDataView<CrosCameraDiagnosticsServiceInterfaceBase>; |
| using CrosCameraDiagnosticsServiceAssociatedRequestDataView = |
| mojo::AssociatedInterfaceRequestDataView<CrosCameraDiagnosticsServiceInterfaceBase>; |
| class CrosCameraControllerInterfaceBase {}; |
| |
| using CrosCameraControllerPtrDataView = |
| mojo::InterfacePtrDataView<CrosCameraControllerInterfaceBase>; |
| using CrosCameraControllerRequestDataView = |
| mojo::InterfaceRequestDataView<CrosCameraControllerInterfaceBase>; |
| using CrosCameraControllerAssociatedPtrInfoDataView = |
| mojo::AssociatedInterfacePtrInfoDataView<CrosCameraControllerInterfaceBase>; |
| using CrosCameraControllerAssociatedRequestDataView = |
| mojo::AssociatedInterfaceRequestDataView<CrosCameraControllerInterfaceBase>; |
| |
| |
| class AnalyzerResultDataView { |
| public: |
| AnalyzerResultDataView() = default; |
| |
| AnalyzerResultDataView( |
| internal::AnalyzerResult_Data* data, |
| mojo::Message* message) |
| : data_(data) {} |
| |
| bool is_null() const { return !data_; } |
| template <typename UserType> |
| [[nodiscard]] bool ReadType(UserType* output) const { |
| auto data_value = data_->type; |
| return mojo::internal::Deserialize<::cros::camera_diag::mojom::AnalyzerType>( |
| data_value, output); |
| } |
| AnalyzerType type() const { |
| return ::mojo::internal::ToKnownEnumValueHelper( |
| static_cast<::cros::camera_diag::mojom::AnalyzerType>(data_->type)); |
| } |
| template <typename UserType> |
| [[nodiscard]] bool ReadStatus(UserType* output) const { |
| auto data_value = data_->status; |
| return mojo::internal::Deserialize<::cros::camera_diag::mojom::AnalyzerStatus>( |
| data_value, output); |
| } |
| AnalyzerStatus status() const { |
| return ::mojo::internal::ToKnownEnumValueHelper( |
| static_cast<::cros::camera_diag::mojom::AnalyzerStatus>(data_->status)); |
| } |
| private: |
| internal::AnalyzerResult_Data* data_ = nullptr; |
| }; |
| |
| |
| class DiagnosticsResultDataView { |
| public: |
| DiagnosticsResultDataView() = default; |
| |
| DiagnosticsResultDataView( |
| internal::DiagnosticsResult_Data* data, |
| mojo::Message* message) |
| : data_(data), message_(message) {} |
| |
| bool is_null() const { return !data_; } |
| uint32_t numeber_of_analyzed_frames() const { |
| return data_->numeber_of_analyzed_frames; |
| } |
| inline void GetAnalyzerResultsDataView( |
| mojo::ArrayDataView<AnalyzerResultDataView>* output); |
| |
| template <typename UserType> |
| [[nodiscard]] bool ReadAnalyzerResults(UserType* output) { |
| |
| auto* pointer = data_->analyzer_results.Get(); |
| return mojo::internal::Deserialize<mojo::ArrayDataView<::cros::camera_diag::mojom::AnalyzerResultDataView>>( |
| pointer, output, message_); |
| } |
| template <typename UserType> |
| [[nodiscard]] bool ReadSuggestedIssue(UserType* output) const { |
| auto data_value = data_->suggested_issue; |
| return mojo::internal::Deserialize<::cros::camera_diag::mojom::CameraIssue>( |
| data_value, output); |
| } |
| CameraIssue suggested_issue() const { |
| return ::mojo::internal::ToKnownEnumValueHelper( |
| static_cast<::cros::camera_diag::mojom::CameraIssue>(data_->suggested_issue)); |
| } |
| private: |
| internal::DiagnosticsResult_Data* data_ = nullptr; |
| mojo::Message* message_ = nullptr; |
| }; |
| |
| |
| class FrameAnalysisConfigDataView { |
| public: |
| FrameAnalysisConfigDataView() = default; |
| |
| FrameAnalysisConfigDataView( |
| internal::FrameAnalysisConfig_Data* data, |
| mojo::Message* message) |
| : data_(data) {} |
| |
| bool is_null() const { return !data_; } |
| template <typename UserType> |
| [[nodiscard]] bool ReadClientType(UserType* output) const { |
| auto data_value = data_->client_type; |
| return mojo::internal::Deserialize<::cros::camera_diag::mojom::ClientType>( |
| data_value, output); |
| } |
| ClientType client_type() const { |
| return ::mojo::internal::ToKnownEnumValueHelper( |
| static_cast<::cros::camera_diag::mojom::ClientType>(data_->client_type)); |
| } |
| uint32_t duration_ms() const { |
| return data_->duration_ms; |
| } |
| private: |
| internal::FrameAnalysisConfig_Data* data_ = nullptr; |
| }; |
| |
| |
| class CameraFrameBufferDataView { |
| public: |
| CameraFrameBufferDataView() = default; |
| |
| CameraFrameBufferDataView( |
| internal::CameraFrameBuffer_Data* data, |
| mojo::Message* message) |
| : data_(data), message_(message) {} |
| |
| bool is_null() const { return !data_; } |
| uint32_t size() const { |
| return data_->size; |
| } |
| mojo::ScopedSharedBufferHandle TakeShmHandle() { |
| mojo::ScopedSharedBufferHandle result; |
| bool ret = |
| mojo::internal::Deserialize<mojo::ScopedSharedBufferHandle>( |
| &data_->shm_handle, &result, message_); |
| DCHECK(ret); |
| return result; |
| } |
| private: |
| internal::CameraFrameBuffer_Data* data_ = nullptr; |
| mojo::Message* message_ = nullptr; |
| }; |
| |
| |
| class CameraStreamDataView { |
| public: |
| CameraStreamDataView() = default; |
| |
| CameraStreamDataView( |
| internal::CameraStream_Data* data, |
| mojo::Message* message) |
| : data_(data) {} |
| |
| bool is_null() const { return !data_; } |
| uint32_t width() const { |
| return data_->width; |
| } |
| uint32_t height() const { |
| return data_->height; |
| } |
| template <typename UserType> |
| [[nodiscard]] bool ReadPixelFormat(UserType* output) const { |
| auto data_value = data_->pixel_format; |
| return mojo::internal::Deserialize<::cros::camera_diag::mojom::PixelFormat>( |
| data_value, output); |
| } |
| PixelFormat pixel_format() const { |
| return ::mojo::internal::ToKnownEnumValueHelper( |
| static_cast<::cros::camera_diag::mojom::PixelFormat>(data_->pixel_format)); |
| } |
| private: |
| internal::CameraStream_Data* data_ = nullptr; |
| }; |
| |
| |
| class CameraFrameDataView { |
| public: |
| CameraFrameDataView() = default; |
| |
| CameraFrameDataView( |
| internal::CameraFrame_Data* data, |
| mojo::Message* message) |
| : data_(data), message_(message) {} |
| |
| bool is_null() const { return !data_; } |
| inline void GetStreamDataView( |
| CameraStreamDataView* output); |
| |
| template <typename UserType> |
| [[nodiscard]] bool ReadStream(UserType* output) { |
| |
| auto* pointer = data_->stream.Get(); |
| return mojo::internal::Deserialize<::cros::camera_diag::mojom::CameraStreamDataView>( |
| pointer, output, message_); |
| } |
| std::optional<uint32_t> frame_number() const { |
| |
| return data_->frame_number_$flag |
| ? std::make_optional(data_->frame_number_$value) |
| : std::nullopt; |
| } |
| template <typename UserType> |
| [[nodiscard]] bool ReadSource(UserType* output) const { |
| auto data_value = data_->source; |
| return mojo::internal::Deserialize<::cros::camera_diag::mojom::DataSource>( |
| data_value, output); |
| } |
| DataSource source() const { |
| return ::mojo::internal::ToKnownEnumValueHelper( |
| static_cast<::cros::camera_diag::mojom::DataSource>(data_->source)); |
| } |
| inline void GetBufferDataView( |
| CameraFrameBufferDataView* output); |
| |
| template <typename UserType> |
| [[nodiscard]] bool ReadBuffer(UserType* output) { |
| |
| auto* pointer = data_->buffer.Get(); |
| return mojo::internal::Deserialize<::cros::camera_diag::mojom::CameraFrameBufferDataView>( |
| pointer, output, message_); |
| } |
| bool is_empty() const { |
| return data_->is_empty; |
| } |
| private: |
| internal::CameraFrame_Data* data_ = nullptr; |
| mojo::Message* message_ = nullptr; |
| }; |
| |
| |
| class StreamingConfigDataView { |
| public: |
| StreamingConfigDataView() = default; |
| |
| StreamingConfigDataView( |
| internal::StreamingConfig_Data* data, |
| mojo::Message* message) |
| : data_(data) {} |
| |
| bool is_null() const { return !data_; } |
| uint32_t frame_interval() const { |
| return data_->frame_interval; |
| } |
| private: |
| internal::StreamingConfig_Data* data_ = nullptr; |
| }; |
| |
| |
| class FrameAnalysisResultDataView { |
| public: |
| using Tag = internal::FrameAnalysisResult_Data::FrameAnalysisResult_Tag; |
| |
| FrameAnalysisResultDataView() = default; |
| |
| FrameAnalysisResultDataView( |
| internal::FrameAnalysisResult_Data* data, |
| mojo::Message* message) |
| : data_(data), message_(message) {} |
| |
| bool is_null() const { |
| // For inlined unions, |data_| is always non-null. In that case we need to |
| // check |data_->is_null()|. |
| return !data_ || data_->is_null(); |
| } |
| |
| Tag tag() const { return data_->tag; } |
| bool is_error() const { return data_->tag == Tag::kError; } |
| template <typename UserType> |
| [[nodiscard]] bool ReadError(UserType* output) const { |
| CHECK(is_error()); |
| return mojo::internal::Deserialize<::cros::camera_diag::mojom::ErrorCode>( |
| data_->data.f_error, output); |
| } |
| ErrorCode error() const { |
| CHECK(is_error()); |
| // TODO(dcheng): This seems incorrect, as it bypasses enum traits. |
| return ::mojo::internal::ToKnownEnumValueHelper( |
| static_cast<::cros::camera_diag::mojom::ErrorCode>(data_->data.f_error)); |
| } |
| bool is_res() const { return data_->tag == Tag::kRes; } |
| inline void GetResDataView( |
| DiagnosticsResultDataView* output) const; |
| |
| template <typename UserType> |
| [[nodiscard]] bool ReadRes(UserType* output) const { |
| |
| CHECK(is_res()); |
| return mojo::internal::Deserialize<::cros::camera_diag::mojom::DiagnosticsResultDataView>( |
| data_->data.f_res.Get(), output, message_); |
| } |
| |
| private: |
| internal::FrameAnalysisResult_Data* data_ = nullptr; |
| mojo::Message* message_ = nullptr; |
| }; |
| |
| |
| |
| class StartStreamingResultDataView { |
| public: |
| using Tag = internal::StartStreamingResult_Data::StartStreamingResult_Tag; |
| |
| StartStreamingResultDataView() = default; |
| |
| StartStreamingResultDataView( |
| internal::StartStreamingResult_Data* data, |
| mojo::Message* message) |
| : data_(data), message_(message) {} |
| |
| bool is_null() const { |
| // For inlined unions, |data_| is always non-null. In that case we need to |
| // check |data_->is_null()|. |
| return !data_ || data_->is_null(); |
| } |
| |
| Tag tag() const { return data_->tag; } |
| bool is_error() const { return data_->tag == Tag::kError; } |
| template <typename UserType> |
| [[nodiscard]] bool ReadError(UserType* output) const { |
| CHECK(is_error()); |
| return mojo::internal::Deserialize<::cros::camera_diag::mojom::ErrorCode>( |
| data_->data.f_error, output); |
| } |
| ErrorCode error() const { |
| CHECK(is_error()); |
| // TODO(dcheng): This seems incorrect, as it bypasses enum traits. |
| return ::mojo::internal::ToKnownEnumValueHelper( |
| static_cast<::cros::camera_diag::mojom::ErrorCode>(data_->data.f_error)); |
| } |
| bool is_stream() const { return data_->tag == Tag::kStream; } |
| inline void GetStreamDataView( |
| CameraStreamDataView* output) const; |
| |
| template <typename UserType> |
| [[nodiscard]] bool ReadStream(UserType* output) const { |
| |
| CHECK(is_stream()); |
| return mojo::internal::Deserialize<::cros::camera_diag::mojom::CameraStreamDataView>( |
| data_->data.f_stream.Get(), output, message_); |
| } |
| |
| private: |
| internal::StartStreamingResult_Data* data_ = nullptr; |
| mojo::Message* message_ = nullptr; |
| }; |
| |
| |
| |
| } // cros::camera_diag::mojom |
| |
| namespace std { |
| |
| template <> |
| struct hash<::cros::camera_diag::mojom::AnalyzerStatus> |
| : public mojo::internal::EnumHashImpl<::cros::camera_diag::mojom::AnalyzerStatus> {}; |
| |
| template <> |
| struct hash<::cros::camera_diag::mojom::AnalyzerType> |
| : public mojo::internal::EnumHashImpl<::cros::camera_diag::mojom::AnalyzerType> {}; |
| |
| template <> |
| struct hash<::cros::camera_diag::mojom::CameraIssue> |
| : public mojo::internal::EnumHashImpl<::cros::camera_diag::mojom::CameraIssue> {}; |
| |
| template <> |
| struct hash<::cros::camera_diag::mojom::ClientType> |
| : public mojo::internal::EnumHashImpl<::cros::camera_diag::mojom::ClientType> {}; |
| |
| template <> |
| struct hash<::cros::camera_diag::mojom::DataSource> |
| : public mojo::internal::EnumHashImpl<::cros::camera_diag::mojom::DataSource> {}; |
| |
| template <> |
| struct hash<::cros::camera_diag::mojom::ErrorCode> |
| : public mojo::internal::EnumHashImpl<::cros::camera_diag::mojom::ErrorCode> {}; |
| |
| template <> |
| struct hash<::cros::camera_diag::mojom::PixelFormat> |
| : public mojo::internal::EnumHashImpl<::cros::camera_diag::mojom::PixelFormat> {}; |
| |
| } // namespace std |
| |
| namespace mojo { |
| |
| |
| namespace internal { |
| |
| template <typename MaybeConstUserType> |
| struct Serializer<::cros::camera_diag::mojom::AnalyzerStatus, MaybeConstUserType> { |
| using UserType = typename std::remove_const<MaybeConstUserType>::type; |
| using Traits = EnumTraits<::cros::camera_diag::mojom::AnalyzerStatus, UserType>; |
| |
| static void Serialize(UserType input, int32_t* output) { |
| *output = static_cast<int32_t>(Traits::ToMojom(input)); |
| } |
| |
| static bool Deserialize(int32_t input, UserType* output) { |
| return Traits::FromMojom(::mojo::internal::ToKnownEnumValueHelper( |
| static_cast<::cros::camera_diag::mojom::AnalyzerStatus>(input)), output); |
| } |
| }; |
| |
| } // namespace internal |
| |
| |
| namespace internal { |
| |
| template <typename MaybeConstUserType> |
| struct Serializer<::cros::camera_diag::mojom::AnalyzerType, MaybeConstUserType> { |
| using UserType = typename std::remove_const<MaybeConstUserType>::type; |
| using Traits = EnumTraits<::cros::camera_diag::mojom::AnalyzerType, UserType>; |
| |
| static void Serialize(UserType input, int32_t* output) { |
| *output = static_cast<int32_t>(Traits::ToMojom(input)); |
| } |
| |
| static bool Deserialize(int32_t input, UserType* output) { |
| return Traits::FromMojom(::mojo::internal::ToKnownEnumValueHelper( |
| static_cast<::cros::camera_diag::mojom::AnalyzerType>(input)), output); |
| } |
| }; |
| |
| } // namespace internal |
| |
| |
| namespace internal { |
| |
| template <typename MaybeConstUserType> |
| struct Serializer<::cros::camera_diag::mojom::CameraIssue, MaybeConstUserType> { |
| using UserType = typename std::remove_const<MaybeConstUserType>::type; |
| using Traits = EnumTraits<::cros::camera_diag::mojom::CameraIssue, UserType>; |
| |
| static void Serialize(UserType input, int32_t* output) { |
| *output = static_cast<int32_t>(Traits::ToMojom(input)); |
| } |
| |
| static bool Deserialize(int32_t input, UserType* output) { |
| return Traits::FromMojom(::mojo::internal::ToKnownEnumValueHelper( |
| static_cast<::cros::camera_diag::mojom::CameraIssue>(input)), output); |
| } |
| }; |
| |
| } // namespace internal |
| |
| |
| namespace internal { |
| |
| template <typename MaybeConstUserType> |
| struct Serializer<::cros::camera_diag::mojom::ClientType, MaybeConstUserType> { |
| using UserType = typename std::remove_const<MaybeConstUserType>::type; |
| using Traits = EnumTraits<::cros::camera_diag::mojom::ClientType, UserType>; |
| |
| static void Serialize(UserType input, int32_t* output) { |
| *output = static_cast<int32_t>(Traits::ToMojom(input)); |
| } |
| |
| static bool Deserialize(int32_t input, UserType* output) { |
| return Traits::FromMojom(::mojo::internal::ToKnownEnumValueHelper( |
| static_cast<::cros::camera_diag::mojom::ClientType>(input)), output); |
| } |
| }; |
| |
| } // namespace internal |
| |
| |
| namespace internal { |
| |
| template <typename MaybeConstUserType> |
| struct Serializer<::cros::camera_diag::mojom::DataSource, MaybeConstUserType> { |
| using UserType = typename std::remove_const<MaybeConstUserType>::type; |
| using Traits = EnumTraits<::cros::camera_diag::mojom::DataSource, UserType>; |
| |
| static void Serialize(UserType input, int32_t* output) { |
| *output = static_cast<int32_t>(Traits::ToMojom(input)); |
| } |
| |
| static bool Deserialize(int32_t input, UserType* output) { |
| return Traits::FromMojom(::mojo::internal::ToKnownEnumValueHelper( |
| static_cast<::cros::camera_diag::mojom::DataSource>(input)), output); |
| } |
| }; |
| |
| } // namespace internal |
| |
| |
| namespace internal { |
| |
| template <typename MaybeConstUserType> |
| struct Serializer<::cros::camera_diag::mojom::ErrorCode, MaybeConstUserType> { |
| using UserType = typename std::remove_const<MaybeConstUserType>::type; |
| using Traits = EnumTraits<::cros::camera_diag::mojom::ErrorCode, UserType>; |
| |
| static void Serialize(UserType input, int32_t* output) { |
| *output = static_cast<int32_t>(Traits::ToMojom(input)); |
| } |
| |
| static bool Deserialize(int32_t input, UserType* output) { |
| return Traits::FromMojom(::mojo::internal::ToKnownEnumValueHelper( |
| static_cast<::cros::camera_diag::mojom::ErrorCode>(input)), output); |
| } |
| }; |
| |
| } // namespace internal |
| |
| |
| namespace internal { |
| |
| template <typename MaybeConstUserType> |
| struct Serializer<::cros::camera_diag::mojom::PixelFormat, MaybeConstUserType> { |
| using UserType = typename std::remove_const<MaybeConstUserType>::type; |
| using Traits = EnumTraits<::cros::camera_diag::mojom::PixelFormat, UserType>; |
| |
| static void Serialize(UserType input, int32_t* output) { |
| *output = static_cast<int32_t>(Traits::ToMojom(input)); |
| } |
| |
| static bool Deserialize(int32_t input, UserType* output) { |
| return Traits::FromMojom(::mojo::internal::ToKnownEnumValueHelper( |
| static_cast<::cros::camera_diag::mojom::PixelFormat>(input)), output); |
| } |
| }; |
| |
| } // namespace internal |
| |
| |
| namespace internal { |
| |
| template <typename MaybeConstUserType> |
| struct Serializer<::cros::camera_diag::mojom::AnalyzerResultDataView, MaybeConstUserType> { |
| using UserType = typename std::remove_const<MaybeConstUserType>::type; |
| using Traits = StructTraits<::cros::camera_diag::mojom::AnalyzerResultDataView, UserType>; |
| |
| static void Serialize( |
| MaybeConstUserType& input, |
| mojo::internal::MessageFragment<::cros::camera_diag::mojom::internal::AnalyzerResult_Data>& fragment) { |
| if (CallIsNullIfExists<Traits>(input)) |
| return; |
| fragment.Allocate(); |
| mojo::internal::Serialize<::cros::camera_diag::mojom::AnalyzerType>( |
| Traits::type(input), &fragment->type); |
| mojo::internal::Serialize<::cros::camera_diag::mojom::AnalyzerStatus>( |
| Traits::status(input), &fragment->status); |
| } |
| |
| static bool Deserialize(::cros::camera_diag::mojom::internal::AnalyzerResult_Data* input, |
| UserType* output, |
| Message* message) { |
| if (!input) |
| return CallSetToNullIfExists<Traits>(output); |
| |
| ::cros::camera_diag::mojom::AnalyzerResultDataView data_view(input, message); |
| return Traits::Read(data_view, output); |
| } |
| }; |
| |
| } // namespace internal |
| |
| |
| namespace internal { |
| |
| template <typename MaybeConstUserType> |
| struct Serializer<::cros::camera_diag::mojom::DiagnosticsResultDataView, MaybeConstUserType> { |
| using UserType = typename std::remove_const<MaybeConstUserType>::type; |
| using Traits = StructTraits<::cros::camera_diag::mojom::DiagnosticsResultDataView, UserType>; |
| |
| static void Serialize( |
| MaybeConstUserType& input, |
| mojo::internal::MessageFragment<::cros::camera_diag::mojom::internal::DiagnosticsResult_Data>& fragment) { |
| if (CallIsNullIfExists<Traits>(input)) |
| return; |
| fragment.Allocate(); |
| fragment->numeber_of_analyzed_frames = Traits::numeber_of_analyzed_frames(input); |
| decltype(Traits::analyzer_results(input)) in_analyzer_results = Traits::analyzer_results(input); |
| mojo::internal::MessageFragment< |
| typename decltype(fragment->analyzer_results)::BaseType> |
| analyzer_results_fragment(fragment.message()); |
| constexpr const mojo::internal::ContainerValidateParams& analyzer_results_validate_params = |
| mojo::internal::GetArrayValidator<0, false, nullptr>(); |
| mojo::internal::Serialize<mojo::ArrayDataView<::cros::camera_diag::mojom::AnalyzerResultDataView>>( |
| in_analyzer_results, analyzer_results_fragment, &analyzer_results_validate_params); |
| fragment->analyzer_results.Set( |
| analyzer_results_fragment.is_null() ? nullptr : analyzer_results_fragment.data()); |
| MOJO_INTERNAL_DLOG_SERIALIZATION_WARNING( |
| fragment->analyzer_results.is_null(), |
| mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER, |
| "null analyzer_results in DiagnosticsResult struct"); |
| mojo::internal::Serialize<::cros::camera_diag::mojom::CameraIssue>( |
| Traits::suggested_issue(input), &fragment->suggested_issue); |
| } |
| |
| static bool Deserialize(::cros::camera_diag::mojom::internal::DiagnosticsResult_Data* input, |
| UserType* output, |
| Message* message) { |
| if (!input) |
| return CallSetToNullIfExists<Traits>(output); |
| |
| ::cros::camera_diag::mojom::DiagnosticsResultDataView data_view(input, message); |
| return Traits::Read(data_view, output); |
| } |
| }; |
| |
| } // namespace internal |
| |
| |
| namespace internal { |
| |
| template <typename MaybeConstUserType> |
| struct Serializer<::cros::camera_diag::mojom::FrameAnalysisConfigDataView, MaybeConstUserType> { |
| using UserType = typename std::remove_const<MaybeConstUserType>::type; |
| using Traits = StructTraits<::cros::camera_diag::mojom::FrameAnalysisConfigDataView, UserType>; |
| |
| static void Serialize( |
| MaybeConstUserType& input, |
| mojo::internal::MessageFragment<::cros::camera_diag::mojom::internal::FrameAnalysisConfig_Data>& fragment) { |
| if (CallIsNullIfExists<Traits>(input)) |
| return; |
| fragment.Allocate(); |
| mojo::internal::Serialize<::cros::camera_diag::mojom::ClientType>( |
| Traits::client_type(input), &fragment->client_type); |
| fragment->duration_ms = Traits::duration_ms(input); |
| } |
| |
| static bool Deserialize(::cros::camera_diag::mojom::internal::FrameAnalysisConfig_Data* input, |
| UserType* output, |
| Message* message) { |
| if (!input) |
| return CallSetToNullIfExists<Traits>(output); |
| |
| ::cros::camera_diag::mojom::FrameAnalysisConfigDataView data_view(input, message); |
| return Traits::Read(data_view, output); |
| } |
| }; |
| |
| } // namespace internal |
| |
| |
| namespace internal { |
| |
| template <typename MaybeConstUserType> |
| struct Serializer<::cros::camera_diag::mojom::CameraFrameBufferDataView, MaybeConstUserType> { |
| using UserType = typename std::remove_const<MaybeConstUserType>::type; |
| using Traits = StructTraits<::cros::camera_diag::mojom::CameraFrameBufferDataView, UserType>; |
| |
| static void Serialize( |
| MaybeConstUserType& input, |
| mojo::internal::MessageFragment<::cros::camera_diag::mojom::internal::CameraFrameBuffer_Data>& fragment) { |
| if (CallIsNullIfExists<Traits>(input)) |
| return; |
| fragment.Allocate(); |
| fragment->size = Traits::size(input); |
| decltype(Traits::shm_handle(input)) in_shm_handle = Traits::shm_handle(input); |
| mojo::internal::Serialize<mojo::ScopedSharedBufferHandle>( |
| in_shm_handle, &fragment->shm_handle, &fragment.message()); |
| MOJO_INTERNAL_DLOG_SERIALIZATION_WARNING( |
| !mojo::internal::IsHandleOrInterfaceValid(fragment->shm_handle), |
| mojo::internal::VALIDATION_ERROR_UNEXPECTED_INVALID_HANDLE, |
| "invalid shm_handle in CameraFrameBuffer struct"); |
| } |
| |
| static bool Deserialize(::cros::camera_diag::mojom::internal::CameraFrameBuffer_Data* input, |
| UserType* output, |
| Message* message) { |
| if (!input) |
| return CallSetToNullIfExists<Traits>(output); |
| |
| ::cros::camera_diag::mojom::CameraFrameBufferDataView data_view(input, message); |
| return Traits::Read(data_view, output); |
| } |
| }; |
| |
| } // namespace internal |
| |
| |
| namespace internal { |
| |
| template <typename MaybeConstUserType> |
| struct Serializer<::cros::camera_diag::mojom::CameraStreamDataView, MaybeConstUserType> { |
| using UserType = typename std::remove_const<MaybeConstUserType>::type; |
| using Traits = StructTraits<::cros::camera_diag::mojom::CameraStreamDataView, UserType>; |
| |
| static void Serialize( |
| MaybeConstUserType& input, |
| mojo::internal::MessageFragment<::cros::camera_diag::mojom::internal::CameraStream_Data>& fragment) { |
| if (CallIsNullIfExists<Traits>(input)) |
| return; |
| fragment.Allocate(); |
| fragment->width = Traits::width(input); |
| fragment->height = Traits::height(input); |
| mojo::internal::Serialize<::cros::camera_diag::mojom::PixelFormat>( |
| Traits::pixel_format(input), &fragment->pixel_format); |
| } |
| |
| static bool Deserialize(::cros::camera_diag::mojom::internal::CameraStream_Data* input, |
| UserType* output, |
| Message* message) { |
| if (!input) |
| return CallSetToNullIfExists<Traits>(output); |
| |
| ::cros::camera_diag::mojom::CameraStreamDataView data_view(input, message); |
| return Traits::Read(data_view, output); |
| } |
| }; |
| |
| } // namespace internal |
| |
| |
| namespace internal { |
| |
| template <typename MaybeConstUserType> |
| struct Serializer<::cros::camera_diag::mojom::CameraFrameDataView, MaybeConstUserType> { |
| using UserType = typename std::remove_const<MaybeConstUserType>::type; |
| using Traits = StructTraits<::cros::camera_diag::mojom::CameraFrameDataView, UserType>; |
| |
| static void Serialize( |
| MaybeConstUserType& input, |
| mojo::internal::MessageFragment<::cros::camera_diag::mojom::internal::CameraFrame_Data>& fragment) { |
| if (CallIsNullIfExists<Traits>(input)) |
| return; |
| fragment.Allocate(); |
| decltype(Traits::stream(input)) in_stream = Traits::stream(input); |
| mojo::internal::MessageFragment< |
| typename decltype(fragment->stream)::BaseType> stream_fragment( |
| fragment.message()); |
| mojo::internal::Serialize<::cros::camera_diag::mojom::CameraStreamDataView>( |
| in_stream, stream_fragment); |
| fragment->stream.Set( |
| stream_fragment.is_null() ? nullptr : stream_fragment.data()); |
| MOJO_INTERNAL_DLOG_SERIALIZATION_WARNING( |
| fragment->stream.is_null(), |
| mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER, |
| "null stream in CameraFrame struct"); |
| fragment->frame_number_$flag = Traits::frame_number(input).has_value(); |
| if (Traits::frame_number(input).has_value()) { |
| fragment->frame_number_$value = Traits::frame_number(input).value(); |
| } |
| mojo::internal::Serialize<::cros::camera_diag::mojom::DataSource>( |
| Traits::source(input), &fragment->source); |
| decltype(Traits::buffer(input)) in_buffer = Traits::buffer(input); |
| mojo::internal::MessageFragment< |
| typename decltype(fragment->buffer)::BaseType> buffer_fragment( |
| fragment.message()); |
| mojo::internal::Serialize<::cros::camera_diag::mojom::CameraFrameBufferDataView>( |
| in_buffer, buffer_fragment); |
| fragment->buffer.Set( |
| buffer_fragment.is_null() ? nullptr : buffer_fragment.data()); |
| MOJO_INTERNAL_DLOG_SERIALIZATION_WARNING( |
| fragment->buffer.is_null(), |
| mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER, |
| "null buffer in CameraFrame struct"); |
| fragment->is_empty = Traits::is_empty(input); |
| } |
| |
| static bool Deserialize(::cros::camera_diag::mojom::internal::CameraFrame_Data* input, |
| UserType* output, |
| Message* message) { |
| if (!input) |
| return CallSetToNullIfExists<Traits>(output); |
| |
| ::cros::camera_diag::mojom::CameraFrameDataView data_view(input, message); |
| return Traits::Read(data_view, output); |
| } |
| }; |
| |
| } // namespace internal |
| |
| |
| namespace internal { |
| |
| template <typename MaybeConstUserType> |
| struct Serializer<::cros::camera_diag::mojom::StreamingConfigDataView, MaybeConstUserType> { |
| using UserType = typename std::remove_const<MaybeConstUserType>::type; |
| using Traits = StructTraits<::cros::camera_diag::mojom::StreamingConfigDataView, UserType>; |
| |
| static void Serialize( |
| MaybeConstUserType& input, |
| mojo::internal::MessageFragment<::cros::camera_diag::mojom::internal::StreamingConfig_Data>& fragment) { |
| if (CallIsNullIfExists<Traits>(input)) |
| return; |
| fragment.Allocate(); |
| fragment->frame_interval = Traits::frame_interval(input); |
| } |
| |
| static bool Deserialize(::cros::camera_diag::mojom::internal::StreamingConfig_Data* input, |
| UserType* output, |
| Message* message) { |
| if (!input) |
| return CallSetToNullIfExists<Traits>(output); |
| |
| ::cros::camera_diag::mojom::StreamingConfigDataView data_view(input, message); |
| return Traits::Read(data_view, output); |
| } |
| }; |
| |
| } // namespace internal |
| |
| |
| namespace internal { |
| |
| template <typename MaybeConstUserType> |
| struct Serializer<::cros::camera_diag::mojom::FrameAnalysisResultDataView, MaybeConstUserType> { |
| using UserType = typename std::remove_const<MaybeConstUserType>::type; |
| using Traits = UnionTraits<::cros::camera_diag::mojom::FrameAnalysisResultDataView, UserType>; |
| |
| static void Serialize(MaybeConstUserType& input, |
| MessageFragment<::cros::camera_diag::mojom::internal::FrameAnalysisResult_Data>& fragment, |
| bool inlined) { |
| if (CallIsNullIfExists<Traits>(input)) { |
| if (inlined) |
| fragment->set_null(); |
| return; |
| } |
| |
| if (!inlined) |
| fragment.Allocate(); |
| |
| // TODO(azani): Handle unknown and objects. |
| // Set the not-null flag. |
| fragment->size = kUnionDataSize; |
| fragment->tag = Traits::GetTag(input); |
| switch (fragment->tag) { |
| case ::cros::camera_diag::mojom::FrameAnalysisResultDataView::Tag::kError: { |
| decltype(Traits::error(input)) |
| in_error = Traits::error(input); |
| mojo::internal::Serialize<::cros::camera_diag::mojom::ErrorCode>( |
| in_error, &fragment->data.f_error); |
| break; |
| } |
| case ::cros::camera_diag::mojom::FrameAnalysisResultDataView::Tag::kRes: { |
| decltype(Traits::res(input)) |
| in_res = Traits::res(input); |
| mojo::internal::MessageFragment< |
| typename decltype(fragment->data.f_res)::BaseType> |
| value_fragment(fragment.message()); |
| mojo::internal::Serialize<::cros::camera_diag::mojom::DiagnosticsResultDataView>( |
| in_res, value_fragment); |
| MOJO_INTERNAL_DLOG_SERIALIZATION_WARNING( |
| value_fragment.is_null(), |
| mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER, |
| "null res in FrameAnalysisResult union"); |
| fragment->data.f_res.Set( |
| value_fragment.is_null() ? nullptr : value_fragment.data()); |
| break; |
| } |
| } |
| } |
| |
| static bool Deserialize(::cros::camera_diag::mojom::internal::FrameAnalysisResult_Data* input, |
| UserType* output, |
| Message* message) { |
| if (!input || input->is_null()) |
| return CallSetToNullIfExists<Traits>(output); |
| |
| ::cros::camera_diag::mojom::FrameAnalysisResultDataView data_view(input, message); |
| return Traits::Read(data_view, output); |
| } |
| }; |
| |
| } // namespace internal |
| |
| |
| namespace internal { |
| |
| template <typename MaybeConstUserType> |
| struct Serializer<::cros::camera_diag::mojom::StartStreamingResultDataView, MaybeConstUserType> { |
| using UserType = typename std::remove_const<MaybeConstUserType>::type; |
| using Traits = UnionTraits<::cros::camera_diag::mojom::StartStreamingResultDataView, UserType>; |
| |
| static void Serialize(MaybeConstUserType& input, |
| MessageFragment<::cros::camera_diag::mojom::internal::StartStreamingResult_Data>& fragment, |
| bool inlined) { |
| if (CallIsNullIfExists<Traits>(input)) { |
| if (inlined) |
| fragment->set_null(); |
| return; |
| } |
| |
| if (!inlined) |
| fragment.Allocate(); |
| |
| // TODO(azani): Handle unknown and objects. |
| // Set the not-null flag. |
| fragment->size = kUnionDataSize; |
| fragment->tag = Traits::GetTag(input); |
| switch (fragment->tag) { |
| case ::cros::camera_diag::mojom::StartStreamingResultDataView::Tag::kError: { |
| decltype(Traits::error(input)) |
| in_error = Traits::error(input); |
| mojo::internal::Serialize<::cros::camera_diag::mojom::ErrorCode>( |
| in_error, &fragment->data.f_error); |
| break; |
| } |
| case ::cros::camera_diag::mojom::StartStreamingResultDataView::Tag::kStream: { |
| decltype(Traits::stream(input)) |
| in_stream = Traits::stream(input); |
| mojo::internal::MessageFragment< |
| typename decltype(fragment->data.f_stream)::BaseType> |
| value_fragment(fragment.message()); |
| mojo::internal::Serialize<::cros::camera_diag::mojom::CameraStreamDataView>( |
| in_stream, value_fragment); |
| MOJO_INTERNAL_DLOG_SERIALIZATION_WARNING( |
| value_fragment.is_null(), |
| mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER, |
| "null stream in StartStreamingResult union"); |
| fragment->data.f_stream.Set( |
| value_fragment.is_null() ? nullptr : value_fragment.data()); |
| break; |
| } |
| } |
| } |
| |
| static bool Deserialize(::cros::camera_diag::mojom::internal::StartStreamingResult_Data* input, |
| UserType* output, |
| Message* message) { |
| if (!input || input->is_null()) |
| return CallSetToNullIfExists<Traits>(output); |
| |
| ::cros::camera_diag::mojom::StartStreamingResultDataView data_view(input, message); |
| return Traits::Read(data_view, output); |
| } |
| }; |
| |
| } // namespace internal |
| |
| } // namespace mojo |
| |
| |
| namespace cros::camera_diag::mojom { |
| |
| |
| |
| inline void DiagnosticsResultDataView::GetAnalyzerResultsDataView( |
| mojo::ArrayDataView<AnalyzerResultDataView>* output) { |
| auto pointer = data_->analyzer_results.Get(); |
| *output = mojo::ArrayDataView<AnalyzerResultDataView>(pointer, message_); |
| } |
| |
| |
| |
| |
| |
| |
| |
| |
| inline void CameraFrameDataView::GetStreamDataView( |
| CameraStreamDataView* output) { |
| auto pointer = data_->stream.Get(); |
| *output = CameraStreamDataView(pointer, message_); |
| } |
| inline void CameraFrameDataView::GetBufferDataView( |
| CameraFrameBufferDataView* output) { |
| auto pointer = data_->buffer.Get(); |
| *output = CameraFrameBufferDataView(pointer, message_); |
| } |
| |
| |
| |
| |
| inline void FrameAnalysisResultDataView::GetResDataView( |
| DiagnosticsResultDataView* output) const { |
| CHECK(is_res()); |
| *output = DiagnosticsResultDataView(data_->data.f_res.Get(), message_); |
| } |
| |
| inline void StartStreamingResultDataView::GetStreamDataView( |
| CameraStreamDataView* output) const { |
| CHECK(is_stream()); |
| *output = CameraStreamDataView(data_->data.f_stream.Get(), message_); |
| } |
| |
| |
| } // cros::camera_diag::mojom |
| |
| // Declare TraceFormatTraits for enums, which should be defined in ::perfetto |
| // namespace. |
| |
| namespace perfetto { |
| |
| template <> |
| struct TraceFormatTraits<::cros::camera_diag::mojom::AnalyzerStatus> { |
| static void WriteIntoTrace(perfetto::TracedValue context, ::cros::camera_diag::mojom::AnalyzerStatus value); |
| }; |
| |
| } // namespace perfetto |
| |
| namespace perfetto { |
| |
| template <> |
| struct TraceFormatTraits<::cros::camera_diag::mojom::AnalyzerType> { |
| static void WriteIntoTrace(perfetto::TracedValue context, ::cros::camera_diag::mojom::AnalyzerType value); |
| }; |
| |
| } // namespace perfetto |
| |
| namespace perfetto { |
| |
| template <> |
| struct TraceFormatTraits<::cros::camera_diag::mojom::CameraIssue> { |
| static void WriteIntoTrace(perfetto::TracedValue context, ::cros::camera_diag::mojom::CameraIssue value); |
| }; |
| |
| } // namespace perfetto |
| |
| namespace perfetto { |
| |
| template <> |
| struct TraceFormatTraits<::cros::camera_diag::mojom::ClientType> { |
| static void WriteIntoTrace(perfetto::TracedValue context, ::cros::camera_diag::mojom::ClientType value); |
| }; |
| |
| } // namespace perfetto |
| |
| namespace perfetto { |
| |
| template <> |
| struct TraceFormatTraits<::cros::camera_diag::mojom::DataSource> { |
| static void WriteIntoTrace(perfetto::TracedValue context, ::cros::camera_diag::mojom::DataSource value); |
| }; |
| |
| } // namespace perfetto |
| |
| namespace perfetto { |
| |
| template <> |
| struct TraceFormatTraits<::cros::camera_diag::mojom::ErrorCode> { |
| static void WriteIntoTrace(perfetto::TracedValue context, ::cros::camera_diag::mojom::ErrorCode value); |
| }; |
| |
| } // namespace perfetto |
| |
| namespace perfetto { |
| |
| template <> |
| struct TraceFormatTraits<::cros::camera_diag::mojom::PixelFormat> { |
| static void WriteIntoTrace(perfetto::TracedValue context, ::cros::camera_diag::mojom::PixelFormat value); |
| }; |
| |
| } // namespace perfetto |
| |
| #endif // CAMERA_MOJO_CAMERA_DIAGNOSTICS_MOJOM_SHARED_H_ |