lens.mojom.cc | Explore in Territory

// chrome/browser/lens/core/mojom/lens.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 "chrome/browser/lens/core/mojom/lens.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 "chrome/browser/lens/core/mojom/lens.mojom-params-data.h"
#include "chrome/browser/lens/core/mojom/lens.mojom-shared-message-ids.h"

#include "chrome/browser/lens/core/mojom/lens.mojom-import-headers.h"
#include "chrome/browser/lens/core/mojom/lens.mojom-test-utils.h"


namespace lens::mojom {
OverlayTheme::OverlayTheme()
    : … { … }

OverlayTheme::OverlayTheme(
    ::SkColor primary_in,
    ::SkColor shader_layer_1_in,
    ::SkColor shader_layer_2_in,
    ::SkColor shader_layer_3_in,
    ::SkColor shader_layer_4_in,
    ::SkColor shader_layer_5_in,
    ::SkColor scrim_in,
    ::SkColor surface_container_highest_light_in,
    ::SkColor surface_container_highest_dark_in,
    ::SkColor selection_element_in)
    : … { … }

OverlayTheme::~OverlayTheme() = default;

void OverlayTheme::WriteIntoTrace(
    perfetto::TracedValue traced_context) const { … }

bool OverlayTheme::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) { … }
const char LensPageHandlerFactory::Name_[] = …;

LensPageHandlerFactory::IPCStableHashFunction LensPageHandlerFactory::MessageToMethodInfo_(mojo::Message& message) { … }


const char* LensPageHandlerFactory::MessageToMethodName_(mojo::Message& message) { … }

#if !BUILDFLAG(IS_FUCHSIA)
uint32_t LensPageHandlerFactory::CreatePageHandler_Sym::IPCStableHash() { … }
uint32_t LensPageHandlerFactory::CreateSidePanelPageHandler_Sym::IPCStableHash() { … }
# endif // !BUILDFLAG(IS_FUCHSIA)

LensPageHandlerFactoryProxy::LensPageHandlerFactoryProxy(mojo::MessageReceiverWithResponder* receiver)
    : … { … }

void LensPageHandlerFactoryProxy::CreatePageHandler(
    ::mojo::PendingReceiver<LensPageHandler> in_handler, ::mojo::PendingRemote<LensPage> in_page) { … }

void LensPageHandlerFactoryProxy::CreateSidePanelPageHandler(
    ::mojo::PendingReceiver<LensSidePanelPageHandler> in_handler, ::mojo::PendingRemote<LensSidePanelPage> in_page) { … }

// static
bool LensPageHandlerFactoryStubDispatch::Accept(
    LensPageHandlerFactory* impl,
    mojo::Message* message) { … }

// static
bool LensPageHandlerFactoryStubDispatch::AcceptWithResponder(
    LensPageHandlerFactory* impl,
    mojo::Message* message,
    std::unique_ptr<mojo::MessageReceiverWithStatus> responder) { … }
namespace {
}  // namespace
static const mojo::internal::GenericValidationInfo kLensPageHandlerFactoryValidationInfo[] = …;

bool LensPageHandlerFactoryRequestValidator::Accept(mojo::Message* message) { … }

const char LensPageHandler::Name_[] = …;

LensPageHandler::IPCStableHashFunction LensPageHandler::MessageToMethodInfo_(mojo::Message& message) { … }


const char* LensPageHandler::MessageToMethodName_(mojo::Message& message) { … }

#if !BUILDFLAG(IS_FUCHSIA)
uint32_t LensPageHandler::ActivityRequestedByOverlay_Sym::IPCStableHash() { … }
uint32_t LensPageHandler::CloseRequestedByOverlayCloseButton_Sym::IPCStableHash() { … }
uint32_t LensPageHandler::CloseRequestedByOverlayBackgroundClick_Sym::IPCStableHash() { … }
uint32_t LensPageHandler::NotifyOverlayInitialized_Sym::IPCStableHash() { … }
uint32_t LensPageHandler::AddBackgroundBlur_Sym::IPCStableHash() { … }
uint32_t LensPageHandler::FeedbackRequestedByOverlay_Sym::IPCStableHash() { … }
uint32_t LensPageHandler::GetOverlayInvocationSource_Sym::IPCStableHash() { … }
uint32_t LensPageHandler::InfoRequestedByOverlay_Sym::IPCStableHash() { … }
uint32_t LensPageHandler::IssueLensRegionRequest_Sym::IPCStableHash() { … }
uint32_t LensPageHandler::IssueLensObjectRequest_Sym::IPCStableHash() { … }
uint32_t LensPageHandler::IssueTextSelectionRequest_Sym::IPCStableHash() { … }
uint32_t LensPageHandler::IssueTranslateSelectionRequest_Sym::IPCStableHash() { … }
uint32_t LensPageHandler::IssueTranslateFullPageRequest_Sym::IPCStableHash() { … }
uint32_t LensPageHandler::CloseSearchBubble_Sym::IPCStableHash() { … }
uint32_t LensPageHandler::CopyText_Sym::IPCStableHash() { … }
uint32_t LensPageHandler::CopyImage_Sym::IPCStableHash() { … }
uint32_t LensPageHandler::SaveAsImage_Sym::IPCStableHash() { … }
uint32_t LensPageHandler::ClosePreselectionBubble_Sym::IPCStableHash() { … }
uint32_t LensPageHandler::RecordUkmAndTaskCompletionForLensOverlayInteraction_Sym::IPCStableHash() { … }
# endif // !BUILDFLAG(IS_FUCHSIA)

class LensPageHandler_GetOverlayInvocationSource_ForwardToCallback
    : public mojo::MessageReceiver { … };

LensPageHandlerProxy::LensPageHandlerProxy(mojo::MessageReceiverWithResponder* receiver)
    : … { … }

void LensPageHandlerProxy::ActivityRequestedByOverlay(
    ::ui::mojom::ClickModifiersPtr in_click_modifiers) { … }

void LensPageHandlerProxy::CloseRequestedByOverlayCloseButton(
    ) { … }

void LensPageHandlerProxy::CloseRequestedByOverlayBackgroundClick(
    ) { … }

void LensPageHandlerProxy::NotifyOverlayInitialized(
    ) { … }

void LensPageHandlerProxy::AddBackgroundBlur(
    ) { … }

void LensPageHandlerProxy::FeedbackRequestedByOverlay(
    ) { … }

void LensPageHandlerProxy::GetOverlayInvocationSource(
    GetOverlayInvocationSourceCallback callback) { … }

void LensPageHandlerProxy::InfoRequestedByOverlay(
    ::ui::mojom::ClickModifiersPtr in_click_modifiers) { … }

void LensPageHandlerProxy::IssueLensRegionRequest(
    ::lens::mojom::CenterRotatedBoxPtr in_region, bool in_is_click) { … }

void LensPageHandlerProxy::IssueLensObjectRequest(
    ::lens::mojom::CenterRotatedBoxPtr in_region, bool in_is_mask_click) { … }

void LensPageHandlerProxy::IssueTextSelectionRequest(
    const std::string& in_query, int32_t in_selection_start_index, int32_t in_selection_end_index) { … }

void LensPageHandlerProxy::IssueTranslateSelectionRequest(
    const std::string& in_query, const std::string& in_content_language, int32_t in_selection_start_index, int32_t in_selection_end_index) { … }

void LensPageHandlerProxy::IssueTranslateFullPageRequest(
    const std::string& in_source_language, const std::string& in_target_language) { … }

void LensPageHandlerProxy::CloseSearchBubble(
    ) { … }

void LensPageHandlerProxy::CopyText(
    const std::string& in_text) { … }

void LensPageHandlerProxy::CopyImage(
    ::lens::mojom::CenterRotatedBoxPtr in_region) { … }

void LensPageHandlerProxy::SaveAsImage(
    ::lens::mojom::CenterRotatedBoxPtr in_region) { … }

void LensPageHandlerProxy::ClosePreselectionBubble(
    ) { … }

void LensPageHandlerProxy::RecordUkmAndTaskCompletionForLensOverlayInteraction(
    UserAction in_user_action) { … }
class LensPageHandler_GetOverlayInvocationSource_ProxyToResponder : public ::mojo::internal::ProxyToResponder { … };

bool LensPageHandler_GetOverlayInvocationSource_ForwardToCallback::Accept(
    mojo::Message* message) { … }

void LensPageHandler_GetOverlayInvocationSource_ProxyToResponder::Run(
    const std::string& in_invocation_source) { … }

// static
bool LensPageHandlerStubDispatch::Accept(
    LensPageHandler* impl,
    mojo::Message* message) { … }

// static
bool LensPageHandlerStubDispatch::AcceptWithResponder(
    LensPageHandler* impl,
    mojo::Message* message,
    std::unique_ptr<mojo::MessageReceiverWithStatus> responder) { … }
namespace {
}  // namespace
static const mojo::internal::GenericValidationInfo kLensPageHandlerValidationInfo[] = …;

bool LensPageHandlerRequestValidator::Accept(mojo::Message* message) { … }

bool LensPageHandlerResponseValidator::Accept(mojo::Message* message) { … }
const char LensPage::Name_[] = …;

LensPage::IPCStableHashFunction LensPage::MessageToMethodInfo_(mojo::Message& message) { … }


const char* LensPage::MessageToMethodName_(mojo::Message& message) { … }

#if !BUILDFLAG(IS_FUCHSIA)
uint32_t LensPage::ScreenshotDataReceived_Sym::IPCStableHash() { … }
uint32_t LensPage::NotifyResultsPanelOpened_Sym::IPCStableHash() { … }
uint32_t LensPage::NotifyOverlayClosing_Sym::IPCStableHash() { … }
uint32_t LensPage::ObjectsReceived_Sym::IPCStableHash() { … }
uint32_t LensPage::TextReceived_Sym::IPCStableHash() { … }
uint32_t LensPage::ThemeReceived_Sym::IPCStableHash() { … }
uint32_t LensPage::SetPostRegionSelection_Sym::IPCStableHash() { … }
uint32_t LensPage::SetTextSelection_Sym::IPCStableHash() { … }
uint32_t LensPage::ClearRegionSelection_Sym::IPCStableHash() { … }
uint32_t LensPage::ClearTextSelection_Sym::IPCStableHash() { … }
uint32_t LensPage::ClearAllSelections_Sym::IPCStableHash() { … }
uint32_t LensPage::TriggerCopyText_Sym::IPCStableHash() { … }
# endif // !BUILDFLAG(IS_FUCHSIA)

LensPageProxy::LensPageProxy(mojo::MessageReceiverWithResponder* receiver)
    : … { … }

void LensPageProxy::ScreenshotDataReceived(
    const ::SkBitmap& in_screenshot_data) { … }

void LensPageProxy::NotifyResultsPanelOpened(
    ) { … }

void LensPageProxy::NotifyOverlayClosing(
    ) { … }

void LensPageProxy::ObjectsReceived(
    std::vector<::lens::mojom::OverlayObjectPtr> in_objects) { … }

void LensPageProxy::TextReceived(
    ::lens::mojom::TextPtr in_text) { … }

void LensPageProxy::ThemeReceived(
    OverlayThemePtr in_theme) { … }

void LensPageProxy::SetPostRegionSelection(
    ::lens::mojom::CenterRotatedBoxPtr in_region) { … }

void LensPageProxy::SetTextSelection(
    int32_t in_selection_start_index, int32_t in_selection_end_index) { … }

void LensPageProxy::ClearRegionSelection(
    ) { … }

void LensPageProxy::ClearTextSelection(
    ) { … }

void LensPageProxy::ClearAllSelections(
    ) { … }

void LensPageProxy::TriggerCopyText(
    ) { … }

// static
bool LensPageStubDispatch::Accept(
    LensPage* impl,
    mojo::Message* message) { … }

// static
bool LensPageStubDispatch::AcceptWithResponder(
    LensPage* impl,
    mojo::Message* message,
    std::unique_ptr<mojo::MessageReceiverWithStatus> responder) { … }
namespace {
}  // namespace
static const mojo::internal::GenericValidationInfo kLensPageValidationInfo[] = …;

bool LensPageRequestValidator::Accept(mojo::Message* message) { … }

const char LensSidePanelPageHandler::Name_[] = …;

LensSidePanelPageHandler::IPCStableHashFunction LensSidePanelPageHandler::MessageToMethodInfo_(mojo::Message& message) { … }


const char* LensSidePanelPageHandler::MessageToMethodName_(mojo::Message& message) { … }

#if !BUILDFLAG(IS_FUCHSIA)
uint32_t LensSidePanelPageHandler::PopAndLoadQueryFromHistory_Sym::IPCStableHash() { … }
# endif // !BUILDFLAG(IS_FUCHSIA)

LensSidePanelPageHandlerProxy::LensSidePanelPageHandlerProxy(mojo::MessageReceiverWithResponder* receiver)
    : … { … }

void LensSidePanelPageHandlerProxy::PopAndLoadQueryFromHistory(
    ) { … }

// static
bool LensSidePanelPageHandlerStubDispatch::Accept(
    LensSidePanelPageHandler* impl,
    mojo::Message* message) { … }

// static
bool LensSidePanelPageHandlerStubDispatch::AcceptWithResponder(
    LensSidePanelPageHandler* impl,
    mojo::Message* message,
    std::unique_ptr<mojo::MessageReceiverWithStatus> responder) { … }
namespace {
}  // namespace
static const mojo::internal::GenericValidationInfo kLensSidePanelPageHandlerValidationInfo[] = …;

bool LensSidePanelPageHandlerRequestValidator::Accept(mojo::Message* message) { … }

const char LensSidePanelPage::Name_[] = …;

LensSidePanelPage::IPCStableHashFunction LensSidePanelPage::MessageToMethodInfo_(mojo::Message& message) { … }


const char* LensSidePanelPage::MessageToMethodName_(mojo::Message& message) { … }

#if !BUILDFLAG(IS_FUCHSIA)
uint32_t LensSidePanelPage::LoadResultsInFrame_Sym::IPCStableHash() { … }
uint32_t LensSidePanelPage::SetIsLoadingResults_Sym::IPCStableHash() { … }
uint32_t LensSidePanelPage::SetBackArrowVisible_Sym::IPCStableHash() { … }
uint32_t LensSidePanelPage::SetShowErrorPage_Sym::IPCStableHash() { … }
# endif // !BUILDFLAG(IS_FUCHSIA)

LensSidePanelPageProxy::LensSidePanelPageProxy(mojo::MessageReceiverWithResponder* receiver)
    : … { … }

void LensSidePanelPageProxy::LoadResultsInFrame(
    const ::GURL& in_results_url) { … }

void LensSidePanelPageProxy::SetIsLoadingResults(
    bool in_is_loading) { … }

void LensSidePanelPageProxy::SetBackArrowVisible(
    bool in_visible) { … }

void LensSidePanelPageProxy::SetShowErrorPage(
    bool in_should_show_error_page) { … }

// static
bool LensSidePanelPageStubDispatch::Accept(
    LensSidePanelPage* impl,
    mojo::Message* message) { … }

// static
bool LensSidePanelPageStubDispatch::AcceptWithResponder(
    LensSidePanelPage* impl,
    mojo::Message* message,
    std::unique_ptr<mojo::MessageReceiverWithStatus> responder) { … }
namespace {
}  // namespace
static const mojo::internal::GenericValidationInfo kLensSidePanelPageValidationInfo[] = …;

bool LensSidePanelPageRequestValidator::Accept(mojo::Message* message) { … }



}  // lens::mojom


namespace mojo {


// static
bool StructTraits<::lens::mojom::OverlayTheme::DataView, ::lens::mojom::OverlayThemePtr>::Read(
    ::lens::mojom::OverlayTheme::DataView input,
    ::lens::mojom::OverlayThemePtr* output) { … }

}  // namespace mojo


// Symbols declared in the -test-utils.h header are defined here instead of a
// separate .cc file to save compile time.


namespace lens::mojom {


void LensPageHandlerFactoryInterceptorForTesting::CreatePageHandler(::mojo::PendingReceiver<LensPageHandler> handler, ::mojo::PendingRemote<LensPage> page) { … }
void LensPageHandlerFactoryInterceptorForTesting::CreateSidePanelPageHandler(::mojo::PendingReceiver<LensSidePanelPageHandler> handler, ::mojo::PendingRemote<LensSidePanelPage> page) { … }
LensPageHandlerFactoryAsyncWaiter::LensPageHandlerFactoryAsyncWaiter(
    LensPageHandlerFactory* proxy) : … { … }

LensPageHandlerFactoryAsyncWaiter::~LensPageHandlerFactoryAsyncWaiter() = default;




void LensPageHandlerInterceptorForTesting::ActivityRequestedByOverlay(::ui::mojom::ClickModifiersPtr click_modifiers) { … }
void LensPageHandlerInterceptorForTesting::CloseRequestedByOverlayCloseButton() { … }
void LensPageHandlerInterceptorForTesting::CloseRequestedByOverlayBackgroundClick() { … }
void LensPageHandlerInterceptorForTesting::NotifyOverlayInitialized() { … }
void LensPageHandlerInterceptorForTesting::AddBackgroundBlur() { … }
void LensPageHandlerInterceptorForTesting::FeedbackRequestedByOverlay() { … }
void LensPageHandlerInterceptorForTesting::GetOverlayInvocationSource(GetOverlayInvocationSourceCallback callback) { … }
void LensPageHandlerInterceptorForTesting::InfoRequestedByOverlay(::ui::mojom::ClickModifiersPtr click_modifiers) { … }
void LensPageHandlerInterceptorForTesting::IssueLensRegionRequest(::lens::mojom::CenterRotatedBoxPtr region, bool is_click) { … }
void LensPageHandlerInterceptorForTesting::IssueLensObjectRequest(::lens::mojom::CenterRotatedBoxPtr region, bool is_mask_click) { … }
void LensPageHandlerInterceptorForTesting::IssueTextSelectionRequest(const std::string& query, int32_t selection_start_index, int32_t selection_end_index) { … }
void LensPageHandlerInterceptorForTesting::IssueTranslateSelectionRequest(const std::string& query, const std::string& content_language, int32_t selection_start_index, int32_t selection_end_index) { … }
void LensPageHandlerInterceptorForTesting::IssueTranslateFullPageRequest(const std::string& source_language, const std::string& target_language) { … }
void LensPageHandlerInterceptorForTesting::CloseSearchBubble() { … }
void LensPageHandlerInterceptorForTesting::CopyText(const std::string& text) { … }
void LensPageHandlerInterceptorForTesting::CopyImage(::lens::mojom::CenterRotatedBoxPtr region) { … }
void LensPageHandlerInterceptorForTesting::SaveAsImage(::lens::mojom::CenterRotatedBoxPtr region) { … }
void LensPageHandlerInterceptorForTesting::ClosePreselectionBubble() { … }
void LensPageHandlerInterceptorForTesting::RecordUkmAndTaskCompletionForLensOverlayInteraction(UserAction user_action) { … }
LensPageHandlerAsyncWaiter::LensPageHandlerAsyncWaiter(
    LensPageHandler* proxy) : … { … }

LensPageHandlerAsyncWaiter::~LensPageHandlerAsyncWaiter() = default;

void LensPageHandlerAsyncWaiter::GetOverlayInvocationSource(
    std::string* out_invocation_source) { … }

std::string LensPageHandlerAsyncWaiter::GetOverlayInvocationSource(
    ) { … }




void LensPageInterceptorForTesting::ScreenshotDataReceived(const ::SkBitmap& screenshot_data) { … }
void LensPageInterceptorForTesting::NotifyResultsPanelOpened() { … }
void LensPageInterceptorForTesting::NotifyOverlayClosing() { … }
void LensPageInterceptorForTesting::ObjectsReceived(std::vector<::lens::mojom::OverlayObjectPtr> objects) { … }
void LensPageInterceptorForTesting::TextReceived(::lens::mojom::TextPtr text) { … }
void LensPageInterceptorForTesting::ThemeReceived(OverlayThemePtr theme) { … }
void LensPageInterceptorForTesting::SetPostRegionSelection(::lens::mojom::CenterRotatedBoxPtr region) { … }
void LensPageInterceptorForTesting::SetTextSelection(int32_t selection_start_index, int32_t selection_end_index) { … }
void LensPageInterceptorForTesting::ClearRegionSelection() { … }
void LensPageInterceptorForTesting::ClearTextSelection() { … }
void LensPageInterceptorForTesting::ClearAllSelections() { … }
void LensPageInterceptorForTesting::TriggerCopyText() { … }
LensPageAsyncWaiter::LensPageAsyncWaiter(
    LensPage* proxy) : … { … }

LensPageAsyncWaiter::~LensPageAsyncWaiter() = default;




void LensSidePanelPageHandlerInterceptorForTesting::PopAndLoadQueryFromHistory() { … }
LensSidePanelPageHandlerAsyncWaiter::LensSidePanelPageHandlerAsyncWaiter(
    LensSidePanelPageHandler* proxy) : … { … }

LensSidePanelPageHandlerAsyncWaiter::~LensSidePanelPageHandlerAsyncWaiter() = default;




void LensSidePanelPageInterceptorForTesting::LoadResultsInFrame(const ::GURL& results_url) { … }
void LensSidePanelPageInterceptorForTesting::SetIsLoadingResults(bool is_loading) { … }
void LensSidePanelPageInterceptorForTesting::SetBackArrowVisible(bool visible) { … }
void LensSidePanelPageInterceptorForTesting::SetShowErrorPage(bool should_show_error_page) { … }
LensSidePanelPageAsyncWaiter::LensSidePanelPageAsyncWaiter(
    LensSidePanelPage* proxy) : … { … }

LensSidePanelPageAsyncWaiter::~LensSidePanelPageAsyncWaiter() = default;






}  // lens::mojom


#if defined(__clang__)
#pragma clang diagnostic pop
#endif
chromium/out/Default/gen/chrome/browser/lens/core/mojom/lens.mojom.cc
