background_fetch.mojom.cc | Explore in Territory

// third_party/blink/public/mojom/background_fetch/background_fetch.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 "third_party/blink/public/mojom/background_fetch/background_fetch.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 "third_party/blink/public/mojom/background_fetch/background_fetch.mojom-params-data.h"
#include "third_party/blink/public/mojom/background_fetch/background_fetch.mojom-shared-message-ids.h"

#include "third_party/blink/public/mojom/background_fetch/background_fetch.mojom-import-headers.h"
#include "third_party/blink/public/mojom/background_fetch/background_fetch.mojom-test-utils.h"
#include "services/network/public/mojom/cookie_access_observer.mojom.h"
#include "services/network/public/mojom/devtools_observer.mojom.h"
#include "services/network/public/mojom/trust_token_access_observer.mojom.h"
#include "third_party/blink/public/common/manifest/manifest_mojom_traits.h"


namespace blink::mojom {
BackgroundFetchSettledFetch::BackgroundFetchSettledFetch()
    : … { … }

BackgroundFetchSettledFetch::BackgroundFetchSettledFetch(
    ::blink::mojom::FetchAPIRequestPtr request_in,
    ::blink::mojom::FetchAPIResponsePtr response_in)
    : … { … }

BackgroundFetchSettledFetch::~BackgroundFetchSettledFetch() = default;

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

bool BackgroundFetchSettledFetch::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) { … }
BackgroundFetchOptions::BackgroundFetchOptions()
    : … { … }

BackgroundFetchOptions::BackgroundFetchOptions(
    std::vector<::blink::Manifest::ImageResource> icons_in,
    uint64_t download_total_in,
    const std::string& title_in)
    : … { … }

BackgroundFetchOptions::~BackgroundFetchOptions() = default;

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

bool BackgroundFetchOptions::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) { … }
BackgroundFetchRegistrationData::BackgroundFetchRegistrationData()
    : … { … }

BackgroundFetchRegistrationData::BackgroundFetchRegistrationData(
    const std::string& developer_id_in,
    uint64_t upload_total_in,
    uint64_t uploaded_in,
    uint64_t download_total_in,
    uint64_t downloaded_in,
    BackgroundFetchResult result_in,
    BackgroundFetchFailureReason failure_reason_in)
    : … { … }

BackgroundFetchRegistrationData::~BackgroundFetchRegistrationData() = default;
size_t BackgroundFetchRegistrationData::Hash(size_t seed) const { … }

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

bool BackgroundFetchRegistrationData::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) { … }
BackgroundFetchRegistration::BackgroundFetchRegistration()
    : … { … }

BackgroundFetchRegistration::BackgroundFetchRegistration(
    BackgroundFetchRegistrationDataPtr registration_data_in,
    ::mojo::PendingRemote<BackgroundFetchRegistrationService> registration_interface_in)
    : … { … }

BackgroundFetchRegistration::~BackgroundFetchRegistration() = default;

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

bool BackgroundFetchRegistration::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) { … }
BackgroundFetchUkmData::BackgroundFetchUkmData()
    : … { … }

BackgroundFetchUkmData::BackgroundFetchUkmData(
    int64_t ideal_to_chosen_icon_size_in)
    : … { … }

BackgroundFetchUkmData::~BackgroundFetchUkmData() = default;
size_t BackgroundFetchUkmData::Hash(size_t seed) const { … }

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

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

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


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

#if !BUILDFLAG(IS_FUCHSIA)
uint32_t BackgroundFetchRegistrationObserver::OnProgress_Sym::IPCStableHash() { … }
uint32_t BackgroundFetchRegistrationObserver::OnRecordsUnavailable_Sym::IPCStableHash() { … }
uint32_t BackgroundFetchRegistrationObserver::OnRequestCompleted_Sym::IPCStableHash() { … }
# endif // !BUILDFLAG(IS_FUCHSIA)

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

void BackgroundFetchRegistrationObserverProxy::OnProgress(
    uint64_t in_upload_total, uint64_t in_uploaded, uint64_t in_download_total, uint64_t in_downloaded, BackgroundFetchResult in_result, BackgroundFetchFailureReason in_failure_reason) { … }

void BackgroundFetchRegistrationObserverProxy::OnRecordsUnavailable(
    ) { … }

void BackgroundFetchRegistrationObserverProxy::OnRequestCompleted(
    ::blink::mojom::FetchAPIRequestPtr in_request, ::blink::mojom::FetchAPIResponsePtr in_response) { … }

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

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

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

const char BackgroundFetchService::Name_[] = …;

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


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

#if !BUILDFLAG(IS_FUCHSIA)
uint32_t BackgroundFetchService::Fetch_Sym::IPCStableHash() { … }
uint32_t BackgroundFetchService::GetRegistration_Sym::IPCStableHash() { … }
uint32_t BackgroundFetchService::GetDeveloperIds_Sym::IPCStableHash() { … }
uint32_t BackgroundFetchService::GetIconDisplaySize_Sym::IPCStableHash() { … }
# endif // !BUILDFLAG(IS_FUCHSIA)

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

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

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

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

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

void BackgroundFetchServiceProxy::Fetch(
    int64_t in_service_worker_registration_id, const std::string& in_developer_id, std::vector<::blink::mojom::FetchAPIRequestPtr> in_requests, BackgroundFetchOptionsPtr in_options, const ::SkBitmap& in_icon, BackgroundFetchUkmDataPtr in_ukm_data, FetchCallback callback) { … }

void BackgroundFetchServiceProxy::GetRegistration(
    int64_t in_service_worker_registration_id, const std::string& in_developer_id, GetRegistrationCallback callback) { … }

void BackgroundFetchServiceProxy::GetDeveloperIds(
    int64_t in_service_worker_registration_id, GetDeveloperIdsCallback callback) { … }

void BackgroundFetchServiceProxy::GetIconDisplaySize(
    GetIconDisplaySizeCallback callback) { … }
class BackgroundFetchService_Fetch_ProxyToResponder : public ::mojo::internal::ProxyToResponder { … };

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

void BackgroundFetchService_Fetch_ProxyToResponder::Run(
    BackgroundFetchError in_error, BackgroundFetchRegistrationPtr in_registration) { … }
class BackgroundFetchService_GetRegistration_ProxyToResponder : public ::mojo::internal::ProxyToResponder { … };

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

void BackgroundFetchService_GetRegistration_ProxyToResponder::Run(
    BackgroundFetchError in_error, BackgroundFetchRegistrationPtr in_registration) { … }
class BackgroundFetchService_GetDeveloperIds_ProxyToResponder : public ::mojo::internal::ProxyToResponder { … };

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

void BackgroundFetchService_GetDeveloperIds_ProxyToResponder::Run(
    BackgroundFetchError in_error, const std::vector<std::string>& in_developer_ids) { … }
class BackgroundFetchService_GetIconDisplaySize_ProxyToResponder : public ::mojo::internal::ProxyToResponder { … };

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

void BackgroundFetchService_GetIconDisplaySize_ProxyToResponder::Run(
    const ::gfx::Size& in_icon_size_pixels) { … }

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

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

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

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

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


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

#if !BUILDFLAG(IS_FUCHSIA)
uint32_t BackgroundFetchRegistrationService::UpdateUI_Sym::IPCStableHash() { … }
uint32_t BackgroundFetchRegistrationService::Abort_Sym::IPCStableHash() { … }
uint32_t BackgroundFetchRegistrationService::MatchRequests_Sym::IPCStableHash() { … }
uint32_t BackgroundFetchRegistrationService::AddRegistrationObserver_Sym::IPCStableHash() { … }
# endif // !BUILDFLAG(IS_FUCHSIA)

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

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

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

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

void BackgroundFetchRegistrationServiceProxy::UpdateUI(
    const std::optional<std::string>& in_title, const ::SkBitmap& in_icon, UpdateUICallback callback) { … }

void BackgroundFetchRegistrationServiceProxy::Abort(
    AbortCallback callback) { … }

void BackgroundFetchRegistrationServiceProxy::MatchRequests(
    ::blink::mojom::FetchAPIRequestPtr in_request_to_match, ::blink::mojom::CacheQueryOptionsPtr in_cache_query_options, bool in_match_all, MatchRequestsCallback callback) { … }

void BackgroundFetchRegistrationServiceProxy::AddRegistrationObserver(
    ::mojo::PendingRemote<BackgroundFetchRegistrationObserver> in_observer) { … }
class BackgroundFetchRegistrationService_UpdateUI_ProxyToResponder : public ::mojo::internal::ProxyToResponder { … };

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

void BackgroundFetchRegistrationService_UpdateUI_ProxyToResponder::Run(
    BackgroundFetchError in_error) { … }
class BackgroundFetchRegistrationService_Abort_ProxyToResponder : public ::mojo::internal::ProxyToResponder { … };

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

void BackgroundFetchRegistrationService_Abort_ProxyToResponder::Run(
    BackgroundFetchError in_error) { … }
class BackgroundFetchRegistrationService_MatchRequests_ProxyToResponder : public ::mojo::internal::ProxyToResponder { … };

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

void BackgroundFetchRegistrationService_MatchRequests_ProxyToResponder::Run(
    std::vector<BackgroundFetchSettledFetchPtr> in_fetches) { … }

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

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

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

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


}  // blink::mojom


namespace mojo {


// static
bool StructTraits<::blink::mojom::BackgroundFetchSettledFetch::DataView, ::blink::mojom::BackgroundFetchSettledFetchPtr>::Read(
    ::blink::mojom::BackgroundFetchSettledFetch::DataView input,
    ::blink::mojom::BackgroundFetchSettledFetchPtr* output) { … }


// static
bool StructTraits<::blink::mojom::BackgroundFetchOptions::DataView, ::blink::mojom::BackgroundFetchOptionsPtr>::Read(
    ::blink::mojom::BackgroundFetchOptions::DataView input,
    ::blink::mojom::BackgroundFetchOptionsPtr* output) { … }


// static
bool StructTraits<::blink::mojom::BackgroundFetchRegistrationData::DataView, ::blink::mojom::BackgroundFetchRegistrationDataPtr>::Read(
    ::blink::mojom::BackgroundFetchRegistrationData::DataView input,
    ::blink::mojom::BackgroundFetchRegistrationDataPtr* output) { … }


// static
bool StructTraits<::blink::mojom::BackgroundFetchRegistration::DataView, ::blink::mojom::BackgroundFetchRegistrationPtr>::Read(
    ::blink::mojom::BackgroundFetchRegistration::DataView input,
    ::blink::mojom::BackgroundFetchRegistrationPtr* output) { … }


// static
bool StructTraits<::blink::mojom::BackgroundFetchUkmData::DataView, ::blink::mojom::BackgroundFetchUkmDataPtr>::Read(
    ::blink::mojom::BackgroundFetchUkmData::DataView input,
    ::blink::mojom::BackgroundFetchUkmDataPtr* 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 blink::mojom {


void BackgroundFetchRegistrationObserverInterceptorForTesting::OnProgress(uint64_t upload_total, uint64_t uploaded, uint64_t download_total, uint64_t downloaded, BackgroundFetchResult result, BackgroundFetchFailureReason failure_reason) { … }
void BackgroundFetchRegistrationObserverInterceptorForTesting::OnRecordsUnavailable() { … }
void BackgroundFetchRegistrationObserverInterceptorForTesting::OnRequestCompleted(::blink::mojom::FetchAPIRequestPtr request, ::blink::mojom::FetchAPIResponsePtr response) { … }
BackgroundFetchRegistrationObserverAsyncWaiter::BackgroundFetchRegistrationObserverAsyncWaiter(
    BackgroundFetchRegistrationObserver* proxy) : … { … }

BackgroundFetchRegistrationObserverAsyncWaiter::~BackgroundFetchRegistrationObserverAsyncWaiter() = default;




void BackgroundFetchServiceInterceptorForTesting::Fetch(int64_t service_worker_registration_id, const std::string& developer_id, std::vector<::blink::mojom::FetchAPIRequestPtr> requests, BackgroundFetchOptionsPtr options, const ::SkBitmap& icon, BackgroundFetchUkmDataPtr ukm_data, FetchCallback callback) { … }
void BackgroundFetchServiceInterceptorForTesting::GetRegistration(int64_t service_worker_registration_id, const std::string& developer_id, GetRegistrationCallback callback) { … }
void BackgroundFetchServiceInterceptorForTesting::GetDeveloperIds(int64_t service_worker_registration_id, GetDeveloperIdsCallback callback) { … }
void BackgroundFetchServiceInterceptorForTesting::GetIconDisplaySize(GetIconDisplaySizeCallback callback) { … }
BackgroundFetchServiceAsyncWaiter::BackgroundFetchServiceAsyncWaiter(
    BackgroundFetchService* proxy) : … { … }

BackgroundFetchServiceAsyncWaiter::~BackgroundFetchServiceAsyncWaiter() = default;

void BackgroundFetchServiceAsyncWaiter::Fetch(
    int64_t service_worker_registration_id, const std::string& developer_id, std::vector<::blink::mojom::FetchAPIRequestPtr> requests, BackgroundFetchOptionsPtr options, const ::SkBitmap& icon, BackgroundFetchUkmDataPtr ukm_data, BackgroundFetchError* out_error, BackgroundFetchRegistrationPtr* out_registration) { … }



void BackgroundFetchServiceAsyncWaiter::GetRegistration(
    int64_t service_worker_registration_id, const std::string& developer_id, BackgroundFetchError* out_error, BackgroundFetchRegistrationPtr* out_registration) { … }



void BackgroundFetchServiceAsyncWaiter::GetDeveloperIds(
    int64_t service_worker_registration_id, BackgroundFetchError* out_error, std::vector<std::string>* out_developer_ids) { … }



void BackgroundFetchServiceAsyncWaiter::GetIconDisplaySize(
    ::gfx::Size* out_icon_size_pixels) { … }

::gfx::Size BackgroundFetchServiceAsyncWaiter::GetIconDisplaySize(
    ) { … }




void BackgroundFetchRegistrationServiceInterceptorForTesting::UpdateUI(const std::optional<std::string>& title, const ::SkBitmap& icon, UpdateUICallback callback) { … }
void BackgroundFetchRegistrationServiceInterceptorForTesting::Abort(AbortCallback callback) { … }
void BackgroundFetchRegistrationServiceInterceptorForTesting::MatchRequests(::blink::mojom::FetchAPIRequestPtr request_to_match, ::blink::mojom::CacheQueryOptionsPtr cache_query_options, bool match_all, MatchRequestsCallback callback) { … }
void BackgroundFetchRegistrationServiceInterceptorForTesting::AddRegistrationObserver(::mojo::PendingRemote<BackgroundFetchRegistrationObserver> observer) { … }
BackgroundFetchRegistrationServiceAsyncWaiter::BackgroundFetchRegistrationServiceAsyncWaiter(
    BackgroundFetchRegistrationService* proxy) : … { … }

BackgroundFetchRegistrationServiceAsyncWaiter::~BackgroundFetchRegistrationServiceAsyncWaiter() = default;

void BackgroundFetchRegistrationServiceAsyncWaiter::UpdateUI(
    const std::optional<std::string>& title, const ::SkBitmap& icon, BackgroundFetchError* out_error) { … }

BackgroundFetchError BackgroundFetchRegistrationServiceAsyncWaiter::UpdateUI(
    const std::optional<std::string>& title, const ::SkBitmap& icon) { … }

void BackgroundFetchRegistrationServiceAsyncWaiter::Abort(
    BackgroundFetchError* out_error) { … }

BackgroundFetchError BackgroundFetchRegistrationServiceAsyncWaiter::Abort(
    ) { … }

void BackgroundFetchRegistrationServiceAsyncWaiter::MatchRequests(
    ::blink::mojom::FetchAPIRequestPtr request_to_match, ::blink::mojom::CacheQueryOptionsPtr cache_query_options, bool match_all, std::vector<BackgroundFetchSettledFetchPtr>* out_fetches) { … }

std::vector<BackgroundFetchSettledFetchPtr> BackgroundFetchRegistrationServiceAsyncWaiter::MatchRequests(
    ::blink::mojom::FetchAPIRequestPtr request_to_match, ::blink::mojom::CacheQueryOptionsPtr cache_query_options, bool match_all) { … }






}  // blink::mojom


#if defined(__clang__)
#pragma clang diagnostic pop
#endif
chromium/out/Default/gen/third_party/blink/public/mojom/background_fetch/background_fetch.mojom.cc
