| // camera/mojo/camera_diagnostics.mojom.cc is auto generated by mojom_bindings_generator.py, do not edit |
| |
| // Copyright 2013 The Chromium Authors |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #if defined(__clang__) |
| #pragma clang diagnostic push |
| #pragma clang diagnostic ignored "-Wunused-private-field" |
| #endif |
| |
| #include "camera/mojo/camera_diagnostics.mojom.h" |
| |
| #include <math.h> |
| #include <stdint.h> |
| #include <utility> |
| |
| #include "base/debug/alias.h" |
| #include "base/hash/md5_constexpr.h" |
| #include "base/run_loop.h" |
| #include "base/strings/string_number_conversions.h" |
| #include "base/task/thread_pool/thread_pool_instance.h" |
| #include "base/trace_event/trace_event.h" |
| #include "base/trace_event/typed_macros.h" |
| #include "mojo/public/cpp/bindings/features.h" |
| #include "mojo/public/cpp/bindings/lib/default_construct_tag_internal.h" |
| #include "mojo/public/cpp/bindings/lib/generated_code_util.h" |
| #include "mojo/public/cpp/bindings/lib/message_internal.h" |
| #include "mojo/public/cpp/bindings/lib/proxy_to_responder.h" |
| #include "mojo/public/cpp/bindings/lib/send_message_helper.h" |
| #include "mojo/public/cpp/bindings/lib/serialization_util.h" |
| #include "mojo/public/cpp/bindings/lib/unserialized_message_context.h" |
| #include "mojo/public/cpp/bindings/lib/validate_params.h" |
| #include "mojo/public/cpp/bindings/lib/validation_errors.h" |
| #include "mojo/public/cpp/bindings/mojo_buildflags.h" |
| #include "mojo/public/cpp/bindings/urgent_message_scope.h" |
| #include "mojo/public/interfaces/bindings/interface_control_messages.mojom.h" |
| #include "third_party/perfetto/include/perfetto/tracing/traced_value.h" |
| |
| #include "camera/mojo/camera_diagnostics.mojom-params-data.h" |
| #include "camera/mojo/camera_diagnostics.mojom-shared-message-ids.h" |
| |
| #include "camera/mojo/camera_diagnostics.mojom-import-headers.h" |
| #include "camera/mojo/camera_diagnostics.mojom-test-utils.h" |
| |
| |
| namespace cros::camera_diag::mojom { |
| constexpr uint32_t FrameAnalysisConfig::kMinDurationMs; |
| constexpr uint32_t FrameAnalysisConfig::kMaxDurationMs; |
| AnalyzerResult::AnalyzerResult() |
| : type(), |
| status() {} |
| |
| AnalyzerResult::AnalyzerResult( |
| AnalyzerType type_in, |
| AnalyzerStatus status_in) |
| : type(std::move(type_in)), |
| status(std::move(status_in)) {} |
| |
| AnalyzerResult::~AnalyzerResult() = default; |
| size_t AnalyzerResult::Hash(size_t seed) const { |
| seed = mojo::internal::Hash(seed, this->type); |
| seed = mojo::internal::Hash(seed, this->status); |
| return seed; |
| } |
| |
| void AnalyzerResult::WriteIntoTrace( |
| perfetto::TracedValue traced_context) const { |
| [[maybe_unused]] auto dict = std::move(traced_context).WriteDictionary(); |
| perfetto::WriteIntoTracedValueWithFallback( |
| dict.AddItem( |
| "type"), this->type, |
| #if BUILDFLAG(MOJO_TRACE_ENABLED) |
| "<value of type AnalyzerType>" |
| #else |
| "<value>" |
| #endif // BUILDFLAG(MOJO_TRACE_ENABLED) |
| ); |
| perfetto::WriteIntoTracedValueWithFallback( |
| dict.AddItem( |
| "status"), this->status, |
| #if BUILDFLAG(MOJO_TRACE_ENABLED) |
| "<value of type AnalyzerStatus>" |
| #else |
| "<value>" |
| #endif // BUILDFLAG(MOJO_TRACE_ENABLED) |
| ); |
| } |
| |
| bool AnalyzerResult::Validate( |
| const void* data, |
| mojo::internal::ValidationContext* validation_context) { |
| return Data_::Validate(data, validation_context); |
| } |
| DiagnosticsResult::DiagnosticsResult() |
| : numeber_of_analyzed_frames(), |
| analyzer_results(), |
| suggested_issue() {} |
| |
| DiagnosticsResult::DiagnosticsResult( |
| uint32_t numeber_of_analyzed_frames_in, |
| std::vector<AnalyzerResultPtr> analyzer_results_in, |
| CameraIssue suggested_issue_in) |
| : numeber_of_analyzed_frames(std::move(numeber_of_analyzed_frames_in)), |
| analyzer_results(std::move(analyzer_results_in)), |
| suggested_issue(std::move(suggested_issue_in)) {} |
| |
| DiagnosticsResult::~DiagnosticsResult() = default; |
| |
| void DiagnosticsResult::WriteIntoTrace( |
| perfetto::TracedValue traced_context) const { |
| [[maybe_unused]] auto dict = std::move(traced_context).WriteDictionary(); |
| perfetto::WriteIntoTracedValueWithFallback( |
| dict.AddItem( |
| "numeber_of_analyzed_frames"), this->numeber_of_analyzed_frames, |
| #if BUILDFLAG(MOJO_TRACE_ENABLED) |
| "<value of type uint32_t>" |
| #else |
| "<value>" |
| #endif // BUILDFLAG(MOJO_TRACE_ENABLED) |
| ); |
| perfetto::WriteIntoTracedValueWithFallback( |
| dict.AddItem( |
| "analyzer_results"), this->analyzer_results, |
| #if BUILDFLAG(MOJO_TRACE_ENABLED) |
| "<value of type std::vector<AnalyzerResultPtr>>" |
| #else |
| "<value>" |
| #endif // BUILDFLAG(MOJO_TRACE_ENABLED) |
| ); |
| perfetto::WriteIntoTracedValueWithFallback( |
| dict.AddItem( |
| "suggested_issue"), this->suggested_issue, |
| #if BUILDFLAG(MOJO_TRACE_ENABLED) |
| "<value of type CameraIssue>" |
| #else |
| "<value>" |
| #endif // BUILDFLAG(MOJO_TRACE_ENABLED) |
| ); |
| } |
| |
| bool DiagnosticsResult::Validate( |
| const void* data, |
| mojo::internal::ValidationContext* validation_context) { |
| return Data_::Validate(data, validation_context); |
| } |
| FrameAnalysisConfig::FrameAnalysisConfig() |
| : client_type(), |
| duration_ms() {} |
| |
| FrameAnalysisConfig::FrameAnalysisConfig( |
| ClientType client_type_in, |
| uint32_t duration_ms_in) |
| : client_type(std::move(client_type_in)), |
| duration_ms(std::move(duration_ms_in)) {} |
| |
| FrameAnalysisConfig::~FrameAnalysisConfig() = default; |
| size_t FrameAnalysisConfig::Hash(size_t seed) const { |
| seed = mojo::internal::Hash(seed, this->client_type); |
| seed = mojo::internal::Hash(seed, this->duration_ms); |
| return seed; |
| } |
| |
| void FrameAnalysisConfig::WriteIntoTrace( |
| perfetto::TracedValue traced_context) const { |
| [[maybe_unused]] auto dict = std::move(traced_context).WriteDictionary(); |
| perfetto::WriteIntoTracedValueWithFallback( |
| dict.AddItem( |
| "client_type"), this->client_type, |
| #if BUILDFLAG(MOJO_TRACE_ENABLED) |
| "<value of type ClientType>" |
| #else |
| "<value>" |
| #endif // BUILDFLAG(MOJO_TRACE_ENABLED) |
| ); |
| perfetto::WriteIntoTracedValueWithFallback( |
| dict.AddItem( |
| "duration_ms"), this->duration_ms, |
| #if BUILDFLAG(MOJO_TRACE_ENABLED) |
| "<value of type uint32_t>" |
| #else |
| "<value>" |
| #endif // BUILDFLAG(MOJO_TRACE_ENABLED) |
| ); |
| } |
| |
| bool FrameAnalysisConfig::Validate( |
| const void* data, |
| mojo::internal::ValidationContext* validation_context) { |
| return Data_::Validate(data, validation_context); |
| } |
| CameraFrameBuffer::CameraFrameBuffer() |
| : size(), |
| shm_handle() {} |
| |
| CameraFrameBuffer::CameraFrameBuffer( |
| uint32_t size_in, |
| ::mojo::ScopedSharedBufferHandle shm_handle_in) |
| : size(std::move(size_in)), |
| shm_handle(std::move(shm_handle_in)) {} |
| |
| CameraFrameBuffer::~CameraFrameBuffer() = default; |
| |
| void CameraFrameBuffer::WriteIntoTrace( |
| perfetto::TracedValue traced_context) const { |
| [[maybe_unused]] auto dict = std::move(traced_context).WriteDictionary(); |
| perfetto::WriteIntoTracedValueWithFallback( |
| dict.AddItem( |
| "size"), this->size, |
| #if BUILDFLAG(MOJO_TRACE_ENABLED) |
| "<value of type uint32_t>" |
| #else |
| "<value>" |
| #endif // BUILDFLAG(MOJO_TRACE_ENABLED) |
| ); |
| perfetto::WriteIntoTracedValueWithFallback( |
| dict.AddItem( |
| "shm_handle"), this->shm_handle, |
| #if BUILDFLAG(MOJO_TRACE_ENABLED) |
| "<value of type ::mojo::ScopedSharedBufferHandle>" |
| #else |
| "<value>" |
| #endif // BUILDFLAG(MOJO_TRACE_ENABLED) |
| ); |
| } |
| |
| bool CameraFrameBuffer::Validate( |
| const void* data, |
| mojo::internal::ValidationContext* validation_context) { |
| return Data_::Validate(data, validation_context); |
| } |
| CameraStream::CameraStream() |
| : width(), |
| height(), |
| pixel_format() {} |
| |
| CameraStream::CameraStream( |
| uint32_t width_in, |
| uint32_t height_in, |
| PixelFormat pixel_format_in) |
| : width(std::move(width_in)), |
| height(std::move(height_in)), |
| pixel_format(std::move(pixel_format_in)) {} |
| |
| CameraStream::~CameraStream() = default; |
| size_t CameraStream::Hash(size_t seed) const { |
| seed = mojo::internal::Hash(seed, this->width); |
| seed = mojo::internal::Hash(seed, this->height); |
| seed = mojo::internal::Hash(seed, this->pixel_format); |
| return seed; |
| } |
| |
| void CameraStream::WriteIntoTrace( |
| perfetto::TracedValue traced_context) const { |
| [[maybe_unused]] auto dict = std::move(traced_context).WriteDictionary(); |
| perfetto::WriteIntoTracedValueWithFallback( |
| dict.AddItem( |
| "width"), this->width, |
| #if BUILDFLAG(MOJO_TRACE_ENABLED) |
| "<value of type uint32_t>" |
| #else |
| "<value>" |
| #endif // BUILDFLAG(MOJO_TRACE_ENABLED) |
| ); |
| perfetto::WriteIntoTracedValueWithFallback( |
| dict.AddItem( |
| "height"), this->height, |
| #if BUILDFLAG(MOJO_TRACE_ENABLED) |
| "<value of type uint32_t>" |
| #else |
| "<value>" |
| #endif // BUILDFLAG(MOJO_TRACE_ENABLED) |
| ); |
| perfetto::WriteIntoTracedValueWithFallback( |
| dict.AddItem( |
| "pixel_format"), this->pixel_format, |
| #if BUILDFLAG(MOJO_TRACE_ENABLED) |
| "<value of type PixelFormat>" |
| #else |
| "<value>" |
| #endif // BUILDFLAG(MOJO_TRACE_ENABLED) |
| ); |
| } |
| |
| bool CameraStream::Validate( |
| const void* data, |
| mojo::internal::ValidationContext* validation_context) { |
| return Data_::Validate(data, validation_context); |
| } |
| CameraFrame::CameraFrame() |
| : stream(), |
| frame_number(), |
| source(), |
| buffer(), |
| is_empty() {} |
| |
| CameraFrame::CameraFrame( |
| CameraStreamPtr stream_in, |
| std::optional<uint32_t> frame_number_in, |
| DataSource source_in, |
| CameraFrameBufferPtr buffer_in, |
| bool is_empty_in) |
| : stream(std::move(stream_in)), |
| frame_number(std::move(frame_number_in)), |
| source(std::move(source_in)), |
| buffer(std::move(buffer_in)), |
| is_empty(std::move(is_empty_in)) {} |
| |
| CameraFrame::~CameraFrame() = default; |
| |
| void CameraFrame::WriteIntoTrace( |
| perfetto::TracedValue traced_context) const { |
| [[maybe_unused]] auto dict = std::move(traced_context).WriteDictionary(); |
| perfetto::WriteIntoTracedValueWithFallback( |
| dict.AddItem( |
| "stream"), this->stream, |
| #if BUILDFLAG(MOJO_TRACE_ENABLED) |
| "<value of type CameraStreamPtr>" |
| #else |
| "<value>" |
| #endif // BUILDFLAG(MOJO_TRACE_ENABLED) |
| ); |
| perfetto::WriteIntoTracedValueWithFallback( |
| dict.AddItem( |
| "frame_number"), this->frame_number, |
| #if BUILDFLAG(MOJO_TRACE_ENABLED) |
| "<value of type std::optional<uint32_t>>" |
| #else |
| "<value>" |
| #endif // BUILDFLAG(MOJO_TRACE_ENABLED) |
| ); |
| perfetto::WriteIntoTracedValueWithFallback( |
| dict.AddItem( |
| "source"), this->source, |
| #if BUILDFLAG(MOJO_TRACE_ENABLED) |
| "<value of type DataSource>" |
| #else |
| "<value>" |
| #endif // BUILDFLAG(MOJO_TRACE_ENABLED) |
| ); |
| perfetto::WriteIntoTracedValueWithFallback( |
| dict.AddItem( |
| "buffer"), this->buffer, |
| #if BUILDFLAG(MOJO_TRACE_ENABLED) |
| "<value of type CameraFrameBufferPtr>" |
| #else |
| "<value>" |
| #endif // BUILDFLAG(MOJO_TRACE_ENABLED) |
| ); |
| perfetto::WriteIntoTracedValueWithFallback( |
| dict.AddItem( |
| "is_empty"), this->is_empty, |
| #if BUILDFLAG(MOJO_TRACE_ENABLED) |
| "<value of type bool>" |
| #else |
| "<value>" |
| #endif // BUILDFLAG(MOJO_TRACE_ENABLED) |
| ); |
| } |
| |
| bool CameraFrame::Validate( |
| const void* data, |
| mojo::internal::ValidationContext* validation_context) { |
| return Data_::Validate(data, validation_context); |
| } |
| StreamingConfig::StreamingConfig() |
| : frame_interval() {} |
| |
| StreamingConfig::StreamingConfig( |
| uint32_t frame_interval_in) |
| : frame_interval(std::move(frame_interval_in)) {} |
| |
| StreamingConfig::~StreamingConfig() = default; |
| size_t StreamingConfig::Hash(size_t seed) const { |
| seed = mojo::internal::Hash(seed, this->frame_interval); |
| return seed; |
| } |
| |
| void StreamingConfig::WriteIntoTrace( |
| perfetto::TracedValue traced_context) const { |
| [[maybe_unused]] auto dict = std::move(traced_context).WriteDictionary(); |
| perfetto::WriteIntoTracedValueWithFallback( |
| dict.AddItem( |
| "frame_interval"), this->frame_interval, |
| #if BUILDFLAG(MOJO_TRACE_ENABLED) |
| "<value of type uint32_t>" |
| #else |
| "<value>" |
| #endif // BUILDFLAG(MOJO_TRACE_ENABLED) |
| ); |
| } |
| |
| bool StreamingConfig::Validate( |
| const void* data, |
| mojo::internal::ValidationContext* validation_context) { |
| return Data_::Validate(data, validation_context); |
| } |
| FrameAnalysisResult::FrameAnalysisResult() : tag_(Tag::kError) { |
| data_.error = ErrorCode(); |
| } |
| |
| FrameAnalysisResult::~FrameAnalysisResult() { |
| DestroyActive(); |
| } |
| |
| |
| void FrameAnalysisResult::set_error( |
| ErrorCode error) { |
| if (tag_ != Tag::kError) { |
| DestroyActive(); |
| tag_ = Tag::kError; |
| } |
| data_.error = error; |
| } |
| void FrameAnalysisResult::set_res( |
| DiagnosticsResultPtr res) { |
| if (tag_ == Tag::kRes) { |
| *(data_.res) = std::move(res); |
| } else { |
| DestroyActive(); |
| tag_ = Tag::kRes; |
| data_.res = new DiagnosticsResultPtr( |
| std::move(res)); |
| } |
| } |
| |
| void FrameAnalysisResult::DestroyActive() { |
| switch (tag_) { |
| |
| case Tag::kError: |
| |
| break; |
| case Tag::kRes: |
| |
| delete data_.res; |
| break; |
| } |
| } |
| |
| bool FrameAnalysisResult::Validate( |
| const void* data, |
| mojo::internal::ValidationContext* validation_context) { |
| return Data_::Validate(data, validation_context, false); |
| } |
| StartStreamingResult::StartStreamingResult() : tag_(Tag::kError) { |
| data_.error = ErrorCode(); |
| } |
| |
| StartStreamingResult::~StartStreamingResult() { |
| DestroyActive(); |
| } |
| |
| |
| void StartStreamingResult::set_error( |
| ErrorCode error) { |
| if (tag_ != Tag::kError) { |
| DestroyActive(); |
| tag_ = Tag::kError; |
| } |
| data_.error = error; |
| } |
| void StartStreamingResult::set_stream( |
| CameraStreamPtr stream) { |
| if (tag_ == Tag::kStream) { |
| *(data_.stream) = std::move(stream); |
| } else { |
| DestroyActive(); |
| tag_ = Tag::kStream; |
| data_.stream = new CameraStreamPtr( |
| std::move(stream)); |
| } |
| } |
| |
| void StartStreamingResult::DestroyActive() { |
| switch (tag_) { |
| |
| case Tag::kError: |
| |
| break; |
| case Tag::kStream: |
| |
| delete data_.stream; |
| break; |
| } |
| } |
| size_t StartStreamingResult::Hash(size_t seed) const { |
| seed = mojo::internal::HashCombine(seed, static_cast<uint32_t>(tag_)); |
| switch (tag_) { |
| |
| case Tag::kError: |
| return mojo::internal::Hash(seed, data_.error); |
| case Tag::kStream: |
| return mojo::internal::Hash(seed, data_.stream); |
| default: |
| NOTREACHED(); |
| return seed; |
| } |
| } |
| |
| bool StartStreamingResult::Validate( |
| const void* data, |
| mojo::internal::ValidationContext* validation_context) { |
| return Data_::Validate(data, validation_context, false); |
| } |
| const char CameraDiagnostics::Name_[] = "cros.camera_diag.mojom.CameraDiagnostics"; |
| |
| CameraDiagnostics::IPCStableHashFunction CameraDiagnostics::MessageToMethodInfo_(mojo::Message& message) { |
| #if !BUILDFLAG(IS_FUCHSIA) |
| switch (static_cast<messages::CameraDiagnostics>(message.name())) { |
| case messages::CameraDiagnostics::kRunFrameAnalysis: { |
| return &CameraDiagnostics::RunFrameAnalysis_Sym::IPCStableHash; |
| } |
| } |
| #endif // !BUILDFLAG(IS_FUCHSIA) |
| return nullptr; |
| } |
| |
| |
| const char* CameraDiagnostics::MessageToMethodName_(mojo::Message& message) { |
| #if BUILDFLAG(MOJO_TRACE_ENABLED) |
| bool is_response = message.has_flag(mojo::Message::kFlagIsResponse); |
| if (!is_response) { |
| switch (static_cast<messages::CameraDiagnostics>(message.name())) { |
| case messages::CameraDiagnostics::kRunFrameAnalysis: |
| return "Receive cros::camera_diag::mojom::CameraDiagnostics::RunFrameAnalysis"; |
| } |
| } else { |
| switch (static_cast<messages::CameraDiagnostics>(message.name())) { |
| case messages::CameraDiagnostics::kRunFrameAnalysis: |
| return "Receive reply cros::camera_diag::mojom::CameraDiagnostics::RunFrameAnalysis"; |
| } |
| } |
| return "Receive unknown mojo message"; |
| #else |
| bool is_response = message.has_flag(mojo::Message::kFlagIsResponse); |
| if (is_response) { |
| return "Receive mojo reply"; |
| } else { |
| return "Receive mojo message"; |
| } |
| #endif // BUILDFLAG(MOJO_TRACE_ENABLED) |
| } |
| |
| #if !BUILDFLAG(IS_FUCHSIA) |
| uint32_t CameraDiagnostics::RunFrameAnalysis_Sym::IPCStableHash() { |
| // This method's address is used for indetifiying the mojo method name after |
| // symbolization. So each IPCStableHash should have a unique address. |
| // We cannot use NO_CODE_FOLDING() here - it relies on the uniqueness of |
| // __LINE__ value, which is not unique accross different mojo modules. |
| // The code below is very similar to NO_CODE_FOLDING, but it uses a unique |
| // hash instead of __LINE__. |
| constexpr uint32_t kHash = base::MD5Hash32Constexpr( |
| "(Impl)cros::camera_diag::mojom::CameraDiagnostics::RunFrameAnalysis"); |
| const uint32_t hash = kHash; |
| base::debug::Alias(&hash); |
| return hash; |
| } |
| # endif // !BUILDFLAG(IS_FUCHSIA) |
| |
| class CameraDiagnostics_RunFrameAnalysis_ForwardToCallback |
| : public mojo::MessageReceiver { |
| public: |
| CameraDiagnostics_RunFrameAnalysis_ForwardToCallback( |
| CameraDiagnostics::RunFrameAnalysisCallback callback |
| ) : callback_(std::move(callback)) { |
| } |
| |
| CameraDiagnostics_RunFrameAnalysis_ForwardToCallback(const CameraDiagnostics_RunFrameAnalysis_ForwardToCallback&) = delete; |
| CameraDiagnostics_RunFrameAnalysis_ForwardToCallback& operator=(const CameraDiagnostics_RunFrameAnalysis_ForwardToCallback&) = delete; |
| |
| bool Accept(mojo::Message* message) override; |
| private: |
| CameraDiagnostics::RunFrameAnalysisCallback callback_; |
| }; |
| |
| CameraDiagnosticsProxy::CameraDiagnosticsProxy(mojo::MessageReceiverWithResponder* receiver) |
| : receiver_(receiver) { |
| } |
| |
| void CameraDiagnosticsProxy::RunFrameAnalysis( |
| FrameAnalysisConfigPtr in_config, RunFrameAnalysisCallback callback) { |
| #if BUILDFLAG(MOJO_TRACE_ENABLED) |
| TRACE_EVENT1( |
| "mojom", "Send cros::camera_diag::mojom::CameraDiagnostics::RunFrameAnalysis", "input_parameters", |
| [&](perfetto::TracedValue context){ |
| auto dict = std::move(context).WriteDictionary(); |
| perfetto::WriteIntoTracedValueWithFallback( |
| dict.AddItem("config"), in_config, |
| "<value of type FrameAnalysisConfigPtr>"); |
| }); |
| #endif |
| |
| const bool kExpectsResponse = true; |
| const bool kIsSync = false; |
| const bool kAllowInterrupt = true; |
| const bool is_urgent = false; |
| |
| const uint32_t kFlags = |
| ((kExpectsResponse) ? mojo::Message::kFlagExpectsResponse : 0) | |
| ((kIsSync) ? mojo::Message::kFlagIsSync : 0) | |
| ((kAllowInterrupt) ? 0 : mojo::Message::kFlagNoInterrupt) | |
| ((is_urgent) ? mojo::Message::kFlagIsUrgent : 0); |
| |
| const size_t estimated_payload_size = |
| 0; |
| mojo::Message message( |
| base::to_underlying(messages::CameraDiagnostics::kRunFrameAnalysis), kFlags, estimated_payload_size); |
| mojo::internal::MessageFragment< |
| ::cros::camera_diag::mojom::internal::CameraDiagnostics_RunFrameAnalysis_Params_Data> params( |
| message); |
| params.Allocate(); |
| mojo::internal::MessageFragment< |
| typename decltype(params->config)::BaseType> config_fragment( |
| params.message()); |
| mojo::internal::Serialize<::cros::camera_diag::mojom::FrameAnalysisConfigDataView>( |
| in_config, config_fragment); |
| params->config.Set( |
| config_fragment.is_null() ? nullptr : config_fragment.data()); |
| MOJO_INTERNAL_DLOG_SERIALIZATION_WARNING( |
| params->config.is_null(), |
| mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER, |
| "null config in CameraDiagnostics.RunFrameAnalysis request"); |
| |
| #if defined(ENABLE_IPC_FUZZER) |
| message.set_interface_name(CameraDiagnostics::Name_); |
| message.set_method_name("RunFrameAnalysis"); |
| #endif |
| std::unique_ptr<mojo::MessageReceiver> responder( |
| new CameraDiagnostics_RunFrameAnalysis_ForwardToCallback( |
| std::move(callback))); |
| ::mojo::internal::SendMojoMessage(*receiver_, message, std::move(responder)); |
| } |
| class CameraDiagnostics_RunFrameAnalysis_ProxyToResponder : public ::mojo::internal::ProxyToResponder { |
| public: |
| static CameraDiagnostics::RunFrameAnalysisCallback CreateCallback( |
| ::mojo::Message& message, |
| std::unique_ptr<mojo::MessageReceiverWithStatus> responder) { |
| std::unique_ptr<CameraDiagnostics_RunFrameAnalysis_ProxyToResponder> proxy( |
| new CameraDiagnostics_RunFrameAnalysis_ProxyToResponder( |
| message, std::move(responder))); |
| return base::BindOnce(&CameraDiagnostics_RunFrameAnalysis_ProxyToResponder::Run, |
| std::move(proxy)); |
| } |
| |
| ~CameraDiagnostics_RunFrameAnalysis_ProxyToResponder() { |
| #if DCHECK_IS_ON() |
| if (responder_) { |
| // If we're being destroyed without being run, we want to ensure the |
| // binding endpoint has been closed. This checks for that asynchronously. |
| // We pass a bound generated callback to handle the response so that any |
| // resulting DCHECK stack will have useful interface type information. |
| // Instantiate a ScopedFizzleBlockShutdownTasks to allow this request to |
| // fizzle if this happens after shutdown and the endpoint is bound to a |
| // BLOCK_SHUTDOWN sequence. |
| base::ThreadPoolInstance::ScopedFizzleBlockShutdownTasks fizzler; |
| responder_->IsConnectedAsync(base::BindOnce(&OnIsConnectedComplete)); |
| } |
| #endif |
| } |
| |
| private: |
| CameraDiagnostics_RunFrameAnalysis_ProxyToResponder( |
| ::mojo::Message& message, |
| std::unique_ptr<mojo::MessageReceiverWithStatus> responder) |
| : ::mojo::internal::ProxyToResponder(message, std::move(responder)) { |
| } |
| |
| #if DCHECK_IS_ON() |
| static void OnIsConnectedComplete(bool connected) { |
| DCHECK(!connected) |
| << "CameraDiagnostics::RunFrameAnalysisCallback was destroyed without " |
| << "first either being run or its corresponding binding being closed. " |
| << "It is an error to drop response callbacks which still correspond " |
| << "to an open interface pipe."; |
| } |
| #endif |
| |
| void Run( |
| FrameAnalysisResultPtr in_res); |
| }; |
| |
| bool CameraDiagnostics_RunFrameAnalysis_ForwardToCallback::Accept( |
| mojo::Message* message) { |
| DCHECK(message->is_serialized()); |
| internal::CameraDiagnostics_RunFrameAnalysis_ResponseParams_Data* params = |
| reinterpret_cast< |
| internal::CameraDiagnostics_RunFrameAnalysis_ResponseParams_Data*>( |
| message->mutable_payload()); |
| |
| |
| // Validation for CameraDiagnostics.0 |
| bool success = true; |
| FrameAnalysisResultPtr p_res{}; |
| CameraDiagnostics_RunFrameAnalysis_ResponseParamsDataView input_data_view(params, message); |
| |
| if (success && !input_data_view.ReadRes(&p_res)) |
| success = false; |
| if (!success) { |
| ReportValidationErrorForMessage( |
| message, |
| mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED, |
| CameraDiagnostics::Name_, 0, true); |
| return false; |
| } |
| if (!callback_.is_null()) |
| std::move(callback_).Run( |
| std::move(p_res)); |
| return true; |
| } |
| |
| void CameraDiagnostics_RunFrameAnalysis_ProxyToResponder::Run( |
| FrameAnalysisResultPtr in_res) { |
| #if BUILDFLAG(MOJO_TRACE_ENABLED) |
| TRACE_EVENT1( |
| "mojom", "Send reply cros::camera_diag::mojom::CameraDiagnostics::RunFrameAnalysis", "async_response_parameters", |
| [&](perfetto::TracedValue context){ |
| auto dict = std::move(context).WriteDictionary(); |
| perfetto::WriteIntoTracedValueWithFallback( |
| dict.AddItem("res"), in_res, |
| "<value of type FrameAnalysisResultPtr>"); |
| }); |
| #endif |
| |
| const uint32_t kFlags = mojo::Message::kFlagIsResponse | |
| ((is_sync_) ? mojo::Message::kFlagIsSync : 0) | |
| ((true) ? 0 : mojo::Message::kFlagNoInterrupt) | |
| ((false) ? mojo::Message::kFlagIsUrgent : 0); |
| |
| const size_t estimated_payload_size = |
| 0; |
| mojo::Message message( |
| base::to_underlying(messages::CameraDiagnostics::kRunFrameAnalysis), kFlags, estimated_payload_size); |
| mojo::internal::MessageFragment< |
| ::cros::camera_diag::mojom::internal::CameraDiagnostics_RunFrameAnalysis_ResponseParams_Data> params( |
| message); |
| params.Allocate(); |
| mojo::internal::MessageFragment<decltype(params->res)> |
| res_fragment(params.message()); |
| res_fragment.Claim(¶ms->res); |
| mojo::internal::Serialize<::cros::camera_diag::mojom::FrameAnalysisResultDataView>( |
| in_res, res_fragment, true); |
| MOJO_INTERNAL_DLOG_SERIALIZATION_WARNING( |
| params->res.is_null(), |
| mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER, |
| "null res in "); |
| |
| #if defined(ENABLE_IPC_FUZZER) |
| message.set_interface_name(CameraDiagnostics::Name_); |
| message.set_method_name("RunFrameAnalysis"); |
| #endif |
| |
| message.set_request_id(request_id_); |
| message.set_trace_nonce(trace_nonce_); |
| ::mojo::internal::SendMojoMessage(*responder_, message); |
| // SendMojoMessage() fails silently if the responder connection is closed, |
| // or if the message is malformed. |
| // |
| // TODO(darin): If Accept() returns false due to a malformed message, that |
| // may be good reason to close the connection. However, we don't have a |
| // way to do that from here. We should add a way. |
| responder_ = nullptr; |
| } |
| |
| // static |
| bool CameraDiagnosticsStubDispatch::Accept( |
| CameraDiagnostics* impl, |
| mojo::Message* message) { |
| switch (static_cast<messages::CameraDiagnostics>(message->header()->name)) { |
| case messages::CameraDiagnostics::kRunFrameAnalysis: { |
| break; |
| } |
| } |
| return false; |
| } |
| |
| // static |
| bool CameraDiagnosticsStubDispatch::AcceptWithResponder( |
| CameraDiagnostics* impl, |
| mojo::Message* message, |
| std::unique_ptr<mojo::MessageReceiverWithStatus> responder) { |
| [[maybe_unused]] const bool message_is_sync = |
| message->has_flag(mojo::Message::kFlagIsSync); |
| [[maybe_unused]] const uint64_t request_id = message->request_id(); |
| switch (static_cast<messages::CameraDiagnostics>(message->header()->name)) { |
| case messages::CameraDiagnostics::kRunFrameAnalysis: { |
| internal::CameraDiagnostics_RunFrameAnalysis_Params_Data* params = |
| reinterpret_cast< |
| internal::CameraDiagnostics_RunFrameAnalysis_Params_Data*>( |
| message->mutable_payload()); |
| |
| |
| // Validation for CameraDiagnostics.0 |
| bool success = true; |
| FrameAnalysisConfigPtr p_config{}; |
| CameraDiagnostics_RunFrameAnalysis_ParamsDataView input_data_view(params, message); |
| |
| if (success && !input_data_view.ReadConfig(&p_config)) |
| success = false; |
| if (!success) { |
| ReportValidationErrorForMessage( |
| message, |
| mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED, |
| CameraDiagnostics::Name_, 0, false); |
| return false; |
| } |
| CameraDiagnostics::RunFrameAnalysisCallback callback = |
| CameraDiagnostics_RunFrameAnalysis_ProxyToResponder::CreateCallback( |
| *message, std::move(responder)); |
| // A null |impl| means no implementation was bound. |
| DCHECK(impl); |
| impl->RunFrameAnalysis( |
| std::move(p_config), std::move(callback)); |
| return true; |
| } |
| } |
| return false; |
| } |
| namespace { |
| } // namespace |
| static const mojo::internal::GenericValidationInfo kCameraDiagnosticsValidationInfo[] = { |
| { &internal::CameraDiagnostics_RunFrameAnalysis_Params_Data::Validate, |
| &internal::CameraDiagnostics_RunFrameAnalysis_ResponseParams_Data::Validate}, |
| }; |
| |
| bool CameraDiagnosticsRequestValidator::Accept(mojo::Message* message) { |
| const char* name = ::cros::camera_diag::mojom::CameraDiagnostics::Name_; |
| return mojo::internal::ValidateRequestGenericPacked(message, name, kCameraDiagnosticsValidationInfo); |
| } |
| |
| bool CameraDiagnosticsResponseValidator::Accept(mojo::Message* message) { |
| const char* name = ::cros::camera_diag::mojom::CameraDiagnostics::Name_; |
| return mojo::internal::ValidateResponseGenericPacked(message, name, kCameraDiagnosticsValidationInfo); |
| } |
| const char CrosCameraDiagnosticsService::Name_[] = "cros.camera_diag.mojom.CrosCameraDiagnosticsService"; |
| |
| CrosCameraDiagnosticsService::IPCStableHashFunction CrosCameraDiagnosticsService::MessageToMethodInfo_(mojo::Message& message) { |
| #if !BUILDFLAG(IS_FUCHSIA) |
| switch (static_cast<messages::CrosCameraDiagnosticsService>(message.name())) { |
| case messages::CrosCameraDiagnosticsService::kSendFrame: { |
| return &CrosCameraDiagnosticsService::SendFrame_Sym::IPCStableHash; |
| } |
| } |
| #endif // !BUILDFLAG(IS_FUCHSIA) |
| return nullptr; |
| } |
| |
| |
| const char* CrosCameraDiagnosticsService::MessageToMethodName_(mojo::Message& message) { |
| #if BUILDFLAG(MOJO_TRACE_ENABLED) |
| bool is_response = message.has_flag(mojo::Message::kFlagIsResponse); |
| if (!is_response) { |
| switch (static_cast<messages::CrosCameraDiagnosticsService>(message.name())) { |
| case messages::CrosCameraDiagnosticsService::kSendFrame: |
| return "Receive cros::camera_diag::mojom::CrosCameraDiagnosticsService::SendFrame"; |
| } |
| } else { |
| switch (static_cast<messages::CrosCameraDiagnosticsService>(message.name())) { |
| case messages::CrosCameraDiagnosticsService::kSendFrame: |
| return "Receive reply cros::camera_diag::mojom::CrosCameraDiagnosticsService::SendFrame"; |
| } |
| } |
| return "Receive unknown mojo message"; |
| #else |
| bool is_response = message.has_flag(mojo::Message::kFlagIsResponse); |
| if (is_response) { |
| return "Receive mojo reply"; |
| } else { |
| return "Receive mojo message"; |
| } |
| #endif // BUILDFLAG(MOJO_TRACE_ENABLED) |
| } |
| |
| #if !BUILDFLAG(IS_FUCHSIA) |
| uint32_t CrosCameraDiagnosticsService::SendFrame_Sym::IPCStableHash() { |
| // This method's address is used for indetifiying the mojo method name after |
| // symbolization. So each IPCStableHash should have a unique address. |
| // We cannot use NO_CODE_FOLDING() here - it relies on the uniqueness of |
| // __LINE__ value, which is not unique accross different mojo modules. |
| // The code below is very similar to NO_CODE_FOLDING, but it uses a unique |
| // hash instead of __LINE__. |
| constexpr uint32_t kHash = base::MD5Hash32Constexpr( |
| "(Impl)cros::camera_diag::mojom::CrosCameraDiagnosticsService::SendFrame"); |
| const uint32_t hash = kHash; |
| base::debug::Alias(&hash); |
| return hash; |
| } |
| # endif // !BUILDFLAG(IS_FUCHSIA) |
| |
| CrosCameraDiagnosticsServiceProxy::CrosCameraDiagnosticsServiceProxy(mojo::MessageReceiverWithResponder* receiver) |
| : receiver_(receiver) { |
| } |
| |
| void CrosCameraDiagnosticsServiceProxy::SendFrame( |
| CameraFramePtr in_frame) { |
| #if BUILDFLAG(MOJO_TRACE_ENABLED) |
| TRACE_EVENT1( |
| "mojom", "Send cros::camera_diag::mojom::CrosCameraDiagnosticsService::SendFrame", "input_parameters", |
| [&](perfetto::TracedValue context){ |
| auto dict = std::move(context).WriteDictionary(); |
| perfetto::WriteIntoTracedValueWithFallback( |
| dict.AddItem("frame"), in_frame, |
| "<value of type CameraFramePtr>"); |
| }); |
| #endif |
| |
| const bool kExpectsResponse = false; |
| const bool kIsSync = false; |
| const bool kAllowInterrupt = true; |
| const bool is_urgent = false; |
| |
| const uint32_t kFlags = |
| ((kExpectsResponse) ? mojo::Message::kFlagExpectsResponse : 0) | |
| ((kIsSync) ? mojo::Message::kFlagIsSync : 0) | |
| ((kAllowInterrupt) ? 0 : mojo::Message::kFlagNoInterrupt) | |
| ((is_urgent) ? mojo::Message::kFlagIsUrgent : 0); |
| |
| const size_t estimated_payload_size = |
| 0; |
| mojo::Message message( |
| base::to_underlying(messages::CrosCameraDiagnosticsService::kSendFrame), kFlags, estimated_payload_size); |
| mojo::internal::MessageFragment< |
| ::cros::camera_diag::mojom::internal::CrosCameraDiagnosticsService_SendFrame_Params_Data> params( |
| message); |
| params.Allocate(); |
| mojo::internal::MessageFragment< |
| typename decltype(params->frame)::BaseType> frame_fragment( |
| params.message()); |
| mojo::internal::Serialize<::cros::camera_diag::mojom::CameraFrameDataView>( |
| in_frame, frame_fragment); |
| params->frame.Set( |
| frame_fragment.is_null() ? nullptr : frame_fragment.data()); |
| MOJO_INTERNAL_DLOG_SERIALIZATION_WARNING( |
| params->frame.is_null(), |
| mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER, |
| "null frame in CrosCameraDiagnosticsService.SendFrame request"); |
| |
| #if defined(ENABLE_IPC_FUZZER) |
| message.set_interface_name(CrosCameraDiagnosticsService::Name_); |
| message.set_method_name("SendFrame"); |
| #endif |
| // This return value may be ignored as false implies the Connector has |
| // encountered an error, which will be visible through other means. |
| ::mojo::internal::SendMojoMessage(*receiver_, message); |
| } |
| |
| // static |
| bool CrosCameraDiagnosticsServiceStubDispatch::Accept( |
| CrosCameraDiagnosticsService* impl, |
| mojo::Message* message) { |
| switch (static_cast<messages::CrosCameraDiagnosticsService>(message->header()->name)) { |
| case messages::CrosCameraDiagnosticsService::kSendFrame: { |
| DCHECK(message->is_serialized()); |
| internal::CrosCameraDiagnosticsService_SendFrame_Params_Data* params = |
| reinterpret_cast<internal::CrosCameraDiagnosticsService_SendFrame_Params_Data*>( |
| message->mutable_payload()); |
| |
| |
| // Validation for CrosCameraDiagnosticsService.0 |
| bool success = true; |
| CameraFramePtr p_frame{}; |
| CrosCameraDiagnosticsService_SendFrame_ParamsDataView input_data_view(params, message); |
| |
| if (success && !input_data_view.ReadFrame(&p_frame)) |
| success = false; |
| if (!success) { |
| ReportValidationErrorForMessage( |
| message, |
| mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED, |
| CrosCameraDiagnosticsService::Name_, 0, false); |
| return false; |
| } |
| // A null |impl| means no implementation was bound. |
| DCHECK(impl); |
| impl->SendFrame( |
| std::move(p_frame)); |
| return true; |
| } |
| } |
| return false; |
| } |
| |
| // static |
| bool CrosCameraDiagnosticsServiceStubDispatch::AcceptWithResponder( |
| CrosCameraDiagnosticsService* impl, |
| mojo::Message* message, |
| std::unique_ptr<mojo::MessageReceiverWithStatus> responder) { |
| [[maybe_unused]] const bool message_is_sync = |
| message->has_flag(mojo::Message::kFlagIsSync); |
| [[maybe_unused]] const uint64_t request_id = message->request_id(); |
| switch (static_cast<messages::CrosCameraDiagnosticsService>(message->header()->name)) { |
| case messages::CrosCameraDiagnosticsService::kSendFrame: { |
| break; |
| } |
| } |
| return false; |
| } |
| namespace { |
| } // namespace |
| static const mojo::internal::GenericValidationInfo kCrosCameraDiagnosticsServiceValidationInfo[] = { |
| { &internal::CrosCameraDiagnosticsService_SendFrame_Params_Data::Validate, |
| nullptr /* no response */}, |
| }; |
| |
| bool CrosCameraDiagnosticsServiceRequestValidator::Accept(mojo::Message* message) { |
| const char* name = ::cros::camera_diag::mojom::CrosCameraDiagnosticsService::Name_; |
| return mojo::internal::ValidateRequestGenericPacked(message, name, kCrosCameraDiagnosticsServiceValidationInfo); |
| } |
| |
| const char CrosCameraController::Name_[] = "cros.camera_diag.mojom.CrosCameraController"; |
| |
| CrosCameraController::IPCStableHashFunction CrosCameraController::MessageToMethodInfo_(mojo::Message& message) { |
| #if !BUILDFLAG(IS_FUCHSIA) |
| switch (static_cast<messages::CrosCameraController>(message.name())) { |
| case messages::CrosCameraController::kStartStreaming: { |
| return &CrosCameraController::StartStreaming_Sym::IPCStableHash; |
| } |
| case messages::CrosCameraController::kStopStreaming: { |
| return &CrosCameraController::StopStreaming_Sym::IPCStableHash; |
| } |
| case messages::CrosCameraController::kRequestFrame: { |
| return &CrosCameraController::RequestFrame_Sym::IPCStableHash; |
| } |
| } |
| #endif // !BUILDFLAG(IS_FUCHSIA) |
| return nullptr; |
| } |
| |
| |
| const char* CrosCameraController::MessageToMethodName_(mojo::Message& message) { |
| #if BUILDFLAG(MOJO_TRACE_ENABLED) |
| bool is_response = message.has_flag(mojo::Message::kFlagIsResponse); |
| if (!is_response) { |
| switch (static_cast<messages::CrosCameraController>(message.name())) { |
| case messages::CrosCameraController::kStartStreaming: |
| return "Receive cros::camera_diag::mojom::CrosCameraController::StartStreaming"; |
| case messages::CrosCameraController::kStopStreaming: |
| return "Receive cros::camera_diag::mojom::CrosCameraController::StopStreaming"; |
| case messages::CrosCameraController::kRequestFrame: |
| return "Receive cros::camera_diag::mojom::CrosCameraController::RequestFrame"; |
| } |
| } else { |
| switch (static_cast<messages::CrosCameraController>(message.name())) { |
| case messages::CrosCameraController::kStartStreaming: |
| return "Receive reply cros::camera_diag::mojom::CrosCameraController::StartStreaming"; |
| case messages::CrosCameraController::kStopStreaming: |
| return "Receive reply cros::camera_diag::mojom::CrosCameraController::StopStreaming"; |
| case messages::CrosCameraController::kRequestFrame: |
| return "Receive reply cros::camera_diag::mojom::CrosCameraController::RequestFrame"; |
| } |
| } |
| return "Receive unknown mojo message"; |
| #else |
| bool is_response = message.has_flag(mojo::Message::kFlagIsResponse); |
| if (is_response) { |
| return "Receive mojo reply"; |
| } else { |
| return "Receive mojo message"; |
| } |
| #endif // BUILDFLAG(MOJO_TRACE_ENABLED) |
| } |
| |
| #if !BUILDFLAG(IS_FUCHSIA) |
| uint32_t CrosCameraController::StartStreaming_Sym::IPCStableHash() { |
| // This method's address is used for indetifiying the mojo method name after |
| // symbolization. So each IPCStableHash should have a unique address. |
| // We cannot use NO_CODE_FOLDING() here - it relies on the uniqueness of |
| // __LINE__ value, which is not unique accross different mojo modules. |
| // The code below is very similar to NO_CODE_FOLDING, but it uses a unique |
| // hash instead of __LINE__. |
| constexpr uint32_t kHash = base::MD5Hash32Constexpr( |
| "(Impl)cros::camera_diag::mojom::CrosCameraController::StartStreaming"); |
| const uint32_t hash = kHash; |
| base::debug::Alias(&hash); |
| return hash; |
| } |
| uint32_t CrosCameraController::StopStreaming_Sym::IPCStableHash() { |
| // This method's address is used for indetifiying the mojo method name after |
| // symbolization. So each IPCStableHash should have a unique address. |
| // We cannot use NO_CODE_FOLDING() here - it relies on the uniqueness of |
| // __LINE__ value, which is not unique accross different mojo modules. |
| // The code below is very similar to NO_CODE_FOLDING, but it uses a unique |
| // hash instead of __LINE__. |
| constexpr uint32_t kHash = base::MD5Hash32Constexpr( |
| "(Impl)cros::camera_diag::mojom::CrosCameraController::StopStreaming"); |
| const uint32_t hash = kHash; |
| base::debug::Alias(&hash); |
| return hash; |
| } |
| uint32_t CrosCameraController::RequestFrame_Sym::IPCStableHash() { |
| // This method's address is used for indetifiying the mojo method name after |
| // symbolization. So each IPCStableHash should have a unique address. |
| // We cannot use NO_CODE_FOLDING() here - it relies on the uniqueness of |
| // __LINE__ value, which is not unique accross different mojo modules. |
| // The code below is very similar to NO_CODE_FOLDING, but it uses a unique |
| // hash instead of __LINE__. |
| constexpr uint32_t kHash = base::MD5Hash32Constexpr( |
| "(Impl)cros::camera_diag::mojom::CrosCameraController::RequestFrame"); |
| const uint32_t hash = kHash; |
| base::debug::Alias(&hash); |
| return hash; |
| } |
| # endif // !BUILDFLAG(IS_FUCHSIA) |
| |
| class CrosCameraController_StartStreaming_ForwardToCallback |
| : public mojo::MessageReceiver { |
| public: |
| CrosCameraController_StartStreaming_ForwardToCallback( |
| CrosCameraController::StartStreamingCallback callback |
| ) : callback_(std::move(callback)) { |
| } |
| |
| CrosCameraController_StartStreaming_ForwardToCallback(const CrosCameraController_StartStreaming_ForwardToCallback&) = delete; |
| CrosCameraController_StartStreaming_ForwardToCallback& operator=(const CrosCameraController_StartStreaming_ForwardToCallback&) = delete; |
| |
| bool Accept(mojo::Message* message) override; |
| private: |
| CrosCameraController::StartStreamingCallback callback_; |
| }; |
| |
| CrosCameraControllerProxy::CrosCameraControllerProxy(mojo::MessageReceiverWithResponder* receiver) |
| : receiver_(receiver) { |
| } |
| |
| void CrosCameraControllerProxy::StartStreaming( |
| StreamingConfigPtr in_config, StartStreamingCallback callback) { |
| #if BUILDFLAG(MOJO_TRACE_ENABLED) |
| TRACE_EVENT1( |
| "mojom", "Send cros::camera_diag::mojom::CrosCameraController::StartStreaming", "input_parameters", |
| [&](perfetto::TracedValue context){ |
| auto dict = std::move(context).WriteDictionary(); |
| perfetto::WriteIntoTracedValueWithFallback( |
| dict.AddItem("config"), in_config, |
| "<value of type StreamingConfigPtr>"); |
| }); |
| #endif |
| |
| const bool kExpectsResponse = true; |
| const bool kIsSync = false; |
| const bool kAllowInterrupt = true; |
| const bool is_urgent = false; |
| |
| const uint32_t kFlags = |
| ((kExpectsResponse) ? mojo::Message::kFlagExpectsResponse : 0) | |
| ((kIsSync) ? mojo::Message::kFlagIsSync : 0) | |
| ((kAllowInterrupt) ? 0 : mojo::Message::kFlagNoInterrupt) | |
| ((is_urgent) ? mojo::Message::kFlagIsUrgent : 0); |
| |
| const size_t estimated_payload_size = |
| 0; |
| mojo::Message message( |
| base::to_underlying(messages::CrosCameraController::kStartStreaming), kFlags, estimated_payload_size); |
| mojo::internal::MessageFragment< |
| ::cros::camera_diag::mojom::internal::CrosCameraController_StartStreaming_Params_Data> params( |
| message); |
| params.Allocate(); |
| mojo::internal::MessageFragment< |
| typename decltype(params->config)::BaseType> config_fragment( |
| params.message()); |
| mojo::internal::Serialize<::cros::camera_diag::mojom::StreamingConfigDataView>( |
| in_config, config_fragment); |
| params->config.Set( |
| config_fragment.is_null() ? nullptr : config_fragment.data()); |
| MOJO_INTERNAL_DLOG_SERIALIZATION_WARNING( |
| params->config.is_null(), |
| mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER, |
| "null config in CrosCameraController.StartStreaming request"); |
| |
| #if defined(ENABLE_IPC_FUZZER) |
| message.set_interface_name(CrosCameraController::Name_); |
| message.set_method_name("StartStreaming"); |
| #endif |
| std::unique_ptr<mojo::MessageReceiver> responder( |
| new CrosCameraController_StartStreaming_ForwardToCallback( |
| std::move(callback))); |
| ::mojo::internal::SendMojoMessage(*receiver_, message, std::move(responder)); |
| } |
| |
| void CrosCameraControllerProxy::StopStreaming( |
| ) { |
| #if BUILDFLAG(MOJO_TRACE_ENABLED) |
| TRACE_EVENT0("mojom", "Send cros::camera_diag::mojom::CrosCameraController::StopStreaming"); |
| #endif |
| |
| const bool kExpectsResponse = false; |
| const bool kIsSync = false; |
| const bool kAllowInterrupt = true; |
| const bool is_urgent = false; |
| |
| const uint32_t kFlags = |
| ((kExpectsResponse) ? mojo::Message::kFlagExpectsResponse : 0) | |
| ((kIsSync) ? mojo::Message::kFlagIsSync : 0) | |
| ((kAllowInterrupt) ? 0 : mojo::Message::kFlagNoInterrupt) | |
| ((is_urgent) ? mojo::Message::kFlagIsUrgent : 0); |
| |
| const size_t estimated_payload_size = |
| 0; |
| mojo::Message message( |
| base::to_underlying(messages::CrosCameraController::kStopStreaming), kFlags, estimated_payload_size); |
| mojo::internal::MessageFragment< |
| ::cros::camera_diag::mojom::internal::CrosCameraController_StopStreaming_Params_Data> params( |
| message); |
| params.Allocate(); |
| |
| #if defined(ENABLE_IPC_FUZZER) |
| message.set_interface_name(CrosCameraController::Name_); |
| message.set_method_name("StopStreaming"); |
| #endif |
| // This return value may be ignored as false implies the Connector has |
| // encountered an error, which will be visible through other means. |
| ::mojo::internal::SendMojoMessage(*receiver_, message); |
| } |
| |
| void CrosCameraControllerProxy::RequestFrame( |
| CameraFramePtr in_frame) { |
| #if BUILDFLAG(MOJO_TRACE_ENABLED) |
| TRACE_EVENT1( |
| "mojom", "Send cros::camera_diag::mojom::CrosCameraController::RequestFrame", "input_parameters", |
| [&](perfetto::TracedValue context){ |
| auto dict = std::move(context).WriteDictionary(); |
| perfetto::WriteIntoTracedValueWithFallback( |
| dict.AddItem("frame"), in_frame, |
| "<value of type CameraFramePtr>"); |
| }); |
| #endif |
| |
| const bool kExpectsResponse = false; |
| const bool kIsSync = false; |
| const bool kAllowInterrupt = true; |
| const bool is_urgent = false; |
| |
| const uint32_t kFlags = |
| ((kExpectsResponse) ? mojo::Message::kFlagExpectsResponse : 0) | |
| ((kIsSync) ? mojo::Message::kFlagIsSync : 0) | |
| ((kAllowInterrupt) ? 0 : mojo::Message::kFlagNoInterrupt) | |
| ((is_urgent) ? mojo::Message::kFlagIsUrgent : 0); |
| |
| const size_t estimated_payload_size = |
| 0; |
| mojo::Message message( |
| base::to_underlying(messages::CrosCameraController::kRequestFrame), kFlags, estimated_payload_size); |
| mojo::internal::MessageFragment< |
| ::cros::camera_diag::mojom::internal::CrosCameraController_RequestFrame_Params_Data> params( |
| message); |
| params.Allocate(); |
| mojo::internal::MessageFragment< |
| typename decltype(params->frame)::BaseType> frame_fragment( |
| params.message()); |
| mojo::internal::Serialize<::cros::camera_diag::mojom::CameraFrameDataView>( |
| in_frame, frame_fragment); |
| params->frame.Set( |
| frame_fragment.is_null() ? nullptr : frame_fragment.data()); |
| MOJO_INTERNAL_DLOG_SERIALIZATION_WARNING( |
| params->frame.is_null(), |
| mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER, |
| "null frame in CrosCameraController.RequestFrame request"); |
| |
| #if defined(ENABLE_IPC_FUZZER) |
| message.set_interface_name(CrosCameraController::Name_); |
| message.set_method_name("RequestFrame"); |
| #endif |
| // This return value may be ignored as false implies the Connector has |
| // encountered an error, which will be visible through other means. |
| ::mojo::internal::SendMojoMessage(*receiver_, message); |
| } |
| class CrosCameraController_StartStreaming_ProxyToResponder : public ::mojo::internal::ProxyToResponder { |
| public: |
| static CrosCameraController::StartStreamingCallback CreateCallback( |
| ::mojo::Message& message, |
| std::unique_ptr<mojo::MessageReceiverWithStatus> responder) { |
| std::unique_ptr<CrosCameraController_StartStreaming_ProxyToResponder> proxy( |
| new CrosCameraController_StartStreaming_ProxyToResponder( |
| message, std::move(responder))); |
| return base::BindOnce(&CrosCameraController_StartStreaming_ProxyToResponder::Run, |
| std::move(proxy)); |
| } |
| |
| ~CrosCameraController_StartStreaming_ProxyToResponder() { |
| #if DCHECK_IS_ON() |
| if (responder_) { |
| // If we're being destroyed without being run, we want to ensure the |
| // binding endpoint has been closed. This checks for that asynchronously. |
| // We pass a bound generated callback to handle the response so that any |
| // resulting DCHECK stack will have useful interface type information. |
| // Instantiate a ScopedFizzleBlockShutdownTasks to allow this request to |
| // fizzle if this happens after shutdown and the endpoint is bound to a |
| // BLOCK_SHUTDOWN sequence. |
| base::ThreadPoolInstance::ScopedFizzleBlockShutdownTasks fizzler; |
| responder_->IsConnectedAsync(base::BindOnce(&OnIsConnectedComplete)); |
| } |
| #endif |
| } |
| |
| private: |
| CrosCameraController_StartStreaming_ProxyToResponder( |
| ::mojo::Message& message, |
| std::unique_ptr<mojo::MessageReceiverWithStatus> responder) |
| : ::mojo::internal::ProxyToResponder(message, std::move(responder)) { |
| } |
| |
| #if DCHECK_IS_ON() |
| static void OnIsConnectedComplete(bool connected) { |
| DCHECK(!connected) |
| << "CrosCameraController::StartStreamingCallback was destroyed without " |
| << "first either being run or its corresponding binding being closed. " |
| << "It is an error to drop response callbacks which still correspond " |
| << "to an open interface pipe."; |
| } |
| #endif |
| |
| void Run( |
| StartStreamingResultPtr in_res); |
| }; |
| |
| bool CrosCameraController_StartStreaming_ForwardToCallback::Accept( |
| mojo::Message* message) { |
| DCHECK(message->is_serialized()); |
| internal::CrosCameraController_StartStreaming_ResponseParams_Data* params = |
| reinterpret_cast< |
| internal::CrosCameraController_StartStreaming_ResponseParams_Data*>( |
| message->mutable_payload()); |
| |
| |
| // Validation for CrosCameraController.0 |
| bool success = true; |
| StartStreamingResultPtr p_res{}; |
| CrosCameraController_StartStreaming_ResponseParamsDataView input_data_view(params, message); |
| |
| if (success && !input_data_view.ReadRes(&p_res)) |
| success = false; |
| if (!success) { |
| ReportValidationErrorForMessage( |
| message, |
| mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED, |
| CrosCameraController::Name_, 0, true); |
| return false; |
| } |
| if (!callback_.is_null()) |
| std::move(callback_).Run( |
| std::move(p_res)); |
| return true; |
| } |
| |
| void CrosCameraController_StartStreaming_ProxyToResponder::Run( |
| StartStreamingResultPtr in_res) { |
| #if BUILDFLAG(MOJO_TRACE_ENABLED) |
| TRACE_EVENT1( |
| "mojom", "Send reply cros::camera_diag::mojom::CrosCameraController::StartStreaming", "async_response_parameters", |
| [&](perfetto::TracedValue context){ |
| auto dict = std::move(context).WriteDictionary(); |
| perfetto::WriteIntoTracedValueWithFallback( |
| dict.AddItem("res"), in_res, |
| "<value of type StartStreamingResultPtr>"); |
| }); |
| #endif |
| |
| const uint32_t kFlags = mojo::Message::kFlagIsResponse | |
| ((is_sync_) ? mojo::Message::kFlagIsSync : 0) | |
| ((true) ? 0 : mojo::Message::kFlagNoInterrupt) | |
| ((false) ? mojo::Message::kFlagIsUrgent : 0); |
| |
| const size_t estimated_payload_size = |
| 0; |
| mojo::Message message( |
| base::to_underlying(messages::CrosCameraController::kStartStreaming), kFlags, estimated_payload_size); |
| mojo::internal::MessageFragment< |
| ::cros::camera_diag::mojom::internal::CrosCameraController_StartStreaming_ResponseParams_Data> params( |
| message); |
| params.Allocate(); |
| mojo::internal::MessageFragment<decltype(params->res)> |
| res_fragment(params.message()); |
| res_fragment.Claim(¶ms->res); |
| mojo::internal::Serialize<::cros::camera_diag::mojom::StartStreamingResultDataView>( |
| in_res, res_fragment, true); |
| MOJO_INTERNAL_DLOG_SERIALIZATION_WARNING( |
| params->res.is_null(), |
| mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER, |
| "null res in "); |
| |
| #if defined(ENABLE_IPC_FUZZER) |
| message.set_interface_name(CrosCameraController::Name_); |
| message.set_method_name("StartStreaming"); |
| #endif |
| |
| message.set_request_id(request_id_); |
| message.set_trace_nonce(trace_nonce_); |
| ::mojo::internal::SendMojoMessage(*responder_, message); |
| // SendMojoMessage() fails silently if the responder connection is closed, |
| // or if the message is malformed. |
| // |
| // TODO(darin): If Accept() returns false due to a malformed message, that |
| // may be good reason to close the connection. However, we don't have a |
| // way to do that from here. We should add a way. |
| responder_ = nullptr; |
| } |
| |
| // static |
| bool CrosCameraControllerStubDispatch::Accept( |
| CrosCameraController* impl, |
| mojo::Message* message) { |
| switch (static_cast<messages::CrosCameraController>(message->header()->name)) { |
| case messages::CrosCameraController::kStartStreaming: { |
| break; |
| } |
| case messages::CrosCameraController::kStopStreaming: { |
| DCHECK(message->is_serialized()); |
| internal::CrosCameraController_StopStreaming_Params_Data* params = |
| reinterpret_cast<internal::CrosCameraController_StopStreaming_Params_Data*>( |
| message->mutable_payload()); |
| |
| |
| // Validation for CrosCameraController.1 |
| bool success = true; |
| CrosCameraController_StopStreaming_ParamsDataView input_data_view(params, message); |
| |
| if (!success) { |
| ReportValidationErrorForMessage( |
| message, |
| mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED, |
| CrosCameraController::Name_, 1, false); |
| return false; |
| } |
| // A null |impl| means no implementation was bound. |
| DCHECK(impl); |
| impl->StopStreaming( ); |
| return true; |
| } |
| case messages::CrosCameraController::kRequestFrame: { |
| DCHECK(message->is_serialized()); |
| internal::CrosCameraController_RequestFrame_Params_Data* params = |
| reinterpret_cast<internal::CrosCameraController_RequestFrame_Params_Data*>( |
| message->mutable_payload()); |
| |
| |
| // Validation for CrosCameraController.2 |
| bool success = true; |
| CameraFramePtr p_frame{}; |
| CrosCameraController_RequestFrame_ParamsDataView input_data_view(params, message); |
| |
| if (success && !input_data_view.ReadFrame(&p_frame)) |
| success = false; |
| if (!success) { |
| ReportValidationErrorForMessage( |
| message, |
| mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED, |
| CrosCameraController::Name_, 2, false); |
| return false; |
| } |
| // A null |impl| means no implementation was bound. |
| DCHECK(impl); |
| impl->RequestFrame( |
| std::move(p_frame)); |
| return true; |
| } |
| } |
| return false; |
| } |
| |
| // static |
| bool CrosCameraControllerStubDispatch::AcceptWithResponder( |
| CrosCameraController* impl, |
| mojo::Message* message, |
| std::unique_ptr<mojo::MessageReceiverWithStatus> responder) { |
| [[maybe_unused]] const bool message_is_sync = |
| message->has_flag(mojo::Message::kFlagIsSync); |
| [[maybe_unused]] const uint64_t request_id = message->request_id(); |
| switch (static_cast<messages::CrosCameraController>(message->header()->name)) { |
| case messages::CrosCameraController::kStartStreaming: { |
| internal::CrosCameraController_StartStreaming_Params_Data* params = |
| reinterpret_cast< |
| internal::CrosCameraController_StartStreaming_Params_Data*>( |
| message->mutable_payload()); |
| |
| |
| // Validation for CrosCameraController.0 |
| bool success = true; |
| StreamingConfigPtr p_config{}; |
| CrosCameraController_StartStreaming_ParamsDataView input_data_view(params, message); |
| |
| if (success && !input_data_view.ReadConfig(&p_config)) |
| success = false; |
| if (!success) { |
| ReportValidationErrorForMessage( |
| message, |
| mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED, |
| CrosCameraController::Name_, 0, false); |
| return false; |
| } |
| CrosCameraController::StartStreamingCallback callback = |
| CrosCameraController_StartStreaming_ProxyToResponder::CreateCallback( |
| *message, std::move(responder)); |
| // A null |impl| means no implementation was bound. |
| DCHECK(impl); |
| impl->StartStreaming( |
| std::move(p_config), std::move(callback)); |
| return true; |
| } |
| case messages::CrosCameraController::kStopStreaming: { |
| break; |
| } |
| case messages::CrosCameraController::kRequestFrame: { |
| break; |
| } |
| } |
| return false; |
| } |
| namespace { |
| } // namespace |
| static const mojo::internal::GenericValidationInfo kCrosCameraControllerValidationInfo[] = { |
| { &internal::CrosCameraController_StartStreaming_Params_Data::Validate, |
| &internal::CrosCameraController_StartStreaming_ResponseParams_Data::Validate}, |
| { &internal::CrosCameraController_StopStreaming_Params_Data::Validate, |
| nullptr /* no response */}, |
| { &internal::CrosCameraController_RequestFrame_Params_Data::Validate, |
| nullptr /* no response */}, |
| }; |
| |
| bool CrosCameraControllerRequestValidator::Accept(mojo::Message* message) { |
| const char* name = ::cros::camera_diag::mojom::CrosCameraController::Name_; |
| return mojo::internal::ValidateRequestGenericPacked(message, name, kCrosCameraControllerValidationInfo); |
| } |
| |
| bool CrosCameraControllerResponseValidator::Accept(mojo::Message* message) { |
| const char* name = ::cros::camera_diag::mojom::CrosCameraController::Name_; |
| return mojo::internal::ValidateResponseGenericPacked(message, name, kCrosCameraControllerValidationInfo); |
| } |
| |
| |
| } // cros::camera_diag::mojom |
| |
| |
| namespace mojo { |
| |
| |
| // static |
| bool StructTraits<::cros::camera_diag::mojom::AnalyzerResult::DataView, ::cros::camera_diag::mojom::AnalyzerResultPtr>::Read( |
| ::cros::camera_diag::mojom::AnalyzerResult::DataView input, |
| ::cros::camera_diag::mojom::AnalyzerResultPtr* output) { |
| bool success = true; |
| ::cros::camera_diag::mojom::AnalyzerResultPtr result(::cros::camera_diag::mojom::AnalyzerResult::New()); |
| |
| if (success && !input.ReadType(&result->type)) |
| success = false; |
| if (success && !input.ReadStatus(&result->status)) |
| success = false; |
| *output = std::move(result); |
| return success; |
| } |
| |
| |
| // static |
| bool StructTraits<::cros::camera_diag::mojom::DiagnosticsResult::DataView, ::cros::camera_diag::mojom::DiagnosticsResultPtr>::Read( |
| ::cros::camera_diag::mojom::DiagnosticsResult::DataView input, |
| ::cros::camera_diag::mojom::DiagnosticsResultPtr* output) { |
| bool success = true; |
| ::cros::camera_diag::mojom::DiagnosticsResultPtr result(::cros::camera_diag::mojom::DiagnosticsResult::New()); |
| |
| if (success) |
| result->numeber_of_analyzed_frames = input.numeber_of_analyzed_frames(); |
| if (success && !input.ReadAnalyzerResults(&result->analyzer_results)) |
| success = false; |
| if (success && !input.ReadSuggestedIssue(&result->suggested_issue)) |
| success = false; |
| *output = std::move(result); |
| return success; |
| } |
| |
| |
| // static |
| bool StructTraits<::cros::camera_diag::mojom::FrameAnalysisConfig::DataView, ::cros::camera_diag::mojom::FrameAnalysisConfigPtr>::Read( |
| ::cros::camera_diag::mojom::FrameAnalysisConfig::DataView input, |
| ::cros::camera_diag::mojom::FrameAnalysisConfigPtr* output) { |
| bool success = true; |
| ::cros::camera_diag::mojom::FrameAnalysisConfigPtr result(::cros::camera_diag::mojom::FrameAnalysisConfig::New()); |
| |
| if (success && !input.ReadClientType(&result->client_type)) |
| success = false; |
| if (success) |
| result->duration_ms = input.duration_ms(); |
| *output = std::move(result); |
| return success; |
| } |
| |
| |
| // static |
| bool StructTraits<::cros::camera_diag::mojom::CameraFrameBuffer::DataView, ::cros::camera_diag::mojom::CameraFrameBufferPtr>::Read( |
| ::cros::camera_diag::mojom::CameraFrameBuffer::DataView input, |
| ::cros::camera_diag::mojom::CameraFrameBufferPtr* output) { |
| bool success = true; |
| ::cros::camera_diag::mojom::CameraFrameBufferPtr result(::cros::camera_diag::mojom::CameraFrameBuffer::New()); |
| |
| if (success) |
| result->size = input.size(); |
| if (success) |
| result->shm_handle = input.TakeShmHandle(); |
| *output = std::move(result); |
| return success; |
| } |
| |
| |
| // static |
| bool StructTraits<::cros::camera_diag::mojom::CameraStream::DataView, ::cros::camera_diag::mojom::CameraStreamPtr>::Read( |
| ::cros::camera_diag::mojom::CameraStream::DataView input, |
| ::cros::camera_diag::mojom::CameraStreamPtr* output) { |
| bool success = true; |
| ::cros::camera_diag::mojom::CameraStreamPtr result(::cros::camera_diag::mojom::CameraStream::New()); |
| |
| if (success) |
| result->width = input.width(); |
| if (success) |
| result->height = input.height(); |
| if (success && !input.ReadPixelFormat(&result->pixel_format)) |
| success = false; |
| *output = std::move(result); |
| return success; |
| } |
| |
| |
| // static |
| bool StructTraits<::cros::camera_diag::mojom::CameraFrame::DataView, ::cros::camera_diag::mojom::CameraFramePtr>::Read( |
| ::cros::camera_diag::mojom::CameraFrame::DataView input, |
| ::cros::camera_diag::mojom::CameraFramePtr* output) { |
| bool success = true; |
| ::cros::camera_diag::mojom::CameraFramePtr result(::cros::camera_diag::mojom::CameraFrame::New()); |
| |
| if (success && !input.ReadStream(&result->stream)) |
| success = false; |
| if (success) { |
| result->frame_number = input.frame_number(); |
| } |
| if (success && !input.ReadSource(&result->source)) |
| success = false; |
| if (success && !input.ReadBuffer(&result->buffer)) |
| success = false; |
| if (success) |
| result->is_empty = input.is_empty(); |
| *output = std::move(result); |
| return success; |
| } |
| |
| |
| // static |
| bool StructTraits<::cros::camera_diag::mojom::StreamingConfig::DataView, ::cros::camera_diag::mojom::StreamingConfigPtr>::Read( |
| ::cros::camera_diag::mojom::StreamingConfig::DataView input, |
| ::cros::camera_diag::mojom::StreamingConfigPtr* output) { |
| bool success = true; |
| ::cros::camera_diag::mojom::StreamingConfigPtr result(::cros::camera_diag::mojom::StreamingConfig::New()); |
| |
| if (success) |
| result->frame_interval = input.frame_interval(); |
| *output = std::move(result); |
| return success; |
| } |
| |
| // static |
| bool UnionTraits<::cros::camera_diag::mojom::FrameAnalysisResult::DataView, ::cros::camera_diag::mojom::FrameAnalysisResultPtr>::Read( |
| ::cros::camera_diag::mojom::FrameAnalysisResult::DataView input, |
| ::cros::camera_diag::mojom::FrameAnalysisResultPtr* output) { |
| using UnionType = ::cros::camera_diag::mojom::FrameAnalysisResult; |
| using Tag = UnionType::Tag; |
| |
| switch (input.tag()) { |
| case Tag::kError: { |
| ::cros::camera_diag::mojom::ErrorCode result_error; |
| if (!input.ReadError(&result_error)) |
| return false; |
| |
| *output = UnionType::NewError(result_error); |
| break; |
| } |
| case Tag::kRes: { |
| ::cros::camera_diag::mojom::DiagnosticsResultPtr result_res; |
| if (!input.ReadRes(&result_res)) |
| return false; |
| |
| *output = UnionType::NewRes( |
| std::move(result_res)); |
| break; |
| } |
| default: |
| |
| return false; |
| } |
| return true; |
| } |
| |
| // static |
| bool UnionTraits<::cros::camera_diag::mojom::StartStreamingResult::DataView, ::cros::camera_diag::mojom::StartStreamingResultPtr>::Read( |
| ::cros::camera_diag::mojom::StartStreamingResult::DataView input, |
| ::cros::camera_diag::mojom::StartStreamingResultPtr* output) { |
| using UnionType = ::cros::camera_diag::mojom::StartStreamingResult; |
| using Tag = UnionType::Tag; |
| |
| switch (input.tag()) { |
| case Tag::kError: { |
| ::cros::camera_diag::mojom::ErrorCode result_error; |
| if (!input.ReadError(&result_error)) |
| return false; |
| |
| *output = UnionType::NewError(result_error); |
| break; |
| } |
| case Tag::kStream: { |
| ::cros::camera_diag::mojom::CameraStreamPtr result_stream; |
| if (!input.ReadStream(&result_stream)) |
| return false; |
| |
| *output = UnionType::NewStream( |
| std::move(result_stream)); |
| break; |
| } |
| default: |
| |
| return false; |
| } |
| return true; |
| } |
| |
| } // namespace mojo |
| |
| |
| // Symbols declared in the -test-utils.h header are defined here instead of a |
| // separate .cc file to save compile time. |
| |
| |
| namespace cros::camera_diag::mojom { |
| |
| |
| void CameraDiagnosticsInterceptorForTesting::RunFrameAnalysis(FrameAnalysisConfigPtr config, RunFrameAnalysisCallback callback) { |
| GetForwardingInterface()->RunFrameAnalysis(std::move(config), std::move(callback)); |
| } |
| CameraDiagnosticsAsyncWaiter::CameraDiagnosticsAsyncWaiter( |
| CameraDiagnostics* proxy) : proxy_(proxy) {} |
| |
| CameraDiagnosticsAsyncWaiter::~CameraDiagnosticsAsyncWaiter() = default; |
| |
| void CameraDiagnosticsAsyncWaiter::RunFrameAnalysis( |
| FrameAnalysisConfigPtr config, FrameAnalysisResultPtr* out_res) { |
| base::RunLoop loop; |
| proxy_->RunFrameAnalysis(std::move(config), |
| base::BindOnce( |
| [](base::RunLoop* loop, |
| FrameAnalysisResultPtr* out_res |
| , |
| FrameAnalysisResultPtr res) {*out_res = std::move(res); |
| loop->Quit(); |
| }, |
| &loop, |
| out_res)); |
| loop.Run(); |
| } |
| |
| FrameAnalysisResultPtr CameraDiagnosticsAsyncWaiter::RunFrameAnalysis( |
| FrameAnalysisConfigPtr config) { |
| FrameAnalysisResultPtr async_wait_result; |
| RunFrameAnalysis(std::move(config),&async_wait_result); |
| return async_wait_result; |
| } |
| |
| |
| |
| |
| void CrosCameraDiagnosticsServiceInterceptorForTesting::SendFrame(CameraFramePtr frame) { |
| GetForwardingInterface()->SendFrame(std::move(frame)); |
| } |
| CrosCameraDiagnosticsServiceAsyncWaiter::CrosCameraDiagnosticsServiceAsyncWaiter( |
| CrosCameraDiagnosticsService* proxy) : proxy_(proxy) {} |
| |
| CrosCameraDiagnosticsServiceAsyncWaiter::~CrosCameraDiagnosticsServiceAsyncWaiter() = default; |
| |
| |
| |
| |
| void CrosCameraControllerInterceptorForTesting::StartStreaming(StreamingConfigPtr config, StartStreamingCallback callback) { |
| GetForwardingInterface()->StartStreaming(std::move(config), std::move(callback)); |
| } |
| void CrosCameraControllerInterceptorForTesting::StopStreaming() { |
| GetForwardingInterface()->StopStreaming(); |
| } |
| void CrosCameraControllerInterceptorForTesting::RequestFrame(CameraFramePtr frame) { |
| GetForwardingInterface()->RequestFrame(std::move(frame)); |
| } |
| CrosCameraControllerAsyncWaiter::CrosCameraControllerAsyncWaiter( |
| CrosCameraController* proxy) : proxy_(proxy) {} |
| |
| CrosCameraControllerAsyncWaiter::~CrosCameraControllerAsyncWaiter() = default; |
| |
| void CrosCameraControllerAsyncWaiter::StartStreaming( |
| StreamingConfigPtr config, StartStreamingResultPtr* out_res) { |
| base::RunLoop loop; |
| proxy_->StartStreaming(std::move(config), |
| base::BindOnce( |
| [](base::RunLoop* loop, |
| StartStreamingResultPtr* out_res |
| , |
| StartStreamingResultPtr res) {*out_res = std::move(res); |
| loop->Quit(); |
| }, |
| &loop, |
| out_res)); |
| loop.Run(); |
| } |
| |
| StartStreamingResultPtr CrosCameraControllerAsyncWaiter::StartStreaming( |
| StreamingConfigPtr config) { |
| StartStreamingResultPtr async_wait_result; |
| StartStreaming(std::move(config),&async_wait_result); |
| return async_wait_result; |
| } |
| |
| |
| |
| |
| |
| |
| } // cros::camera_diag::mojom |
| |
| |
| #if defined(__clang__) |
| #pragma clang diagnostic pop |
| #endif |