win-Debug/gen/services/viz/privileged/interfaces/compositing/renderer_settings.mojom-blink.cc

// Copyright 2013 The Chromium Authors. All rights reserved.
// 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"
#elif defined(_MSC_VER)
#pragma warning(push)
#pragma warning(disable:4056)
#pragma warning(disable:4065)
#pragma warning(disable:4756)
#endif

#include "services/viz/privileged/interfaces/compositing/renderer_settings.mojom-blink.h"

#include <math.h>
#include <stdint.h>
#include <utility>

#include "base/hash/md5_constexpr.h"
#include "base/logging.h"
#include "base/run_loop.h"
#include "base/task/common/task_annotator.h"
#include "mojo/public/cpp/bindings/lib/message_internal.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_context.h"
#include "mojo/public/cpp/bindings/lib/validation_errors.h"
#include "mojo/public/interfaces/bindings/interface_control_messages.mojom.h"

#include "services/viz/privileged/interfaces/compositing/renderer_settings.mojom-params-data.h"
#include "services/viz/privileged/interfaces/compositing/renderer_settings.mojom-shared-message-ids.h"

#include "services/viz/privileged/interfaces/compositing/renderer_settings.mojom-blink-import-headers.h"
#include "mojo/public/cpp/bindings/lib/wtf_serialization.h"


#ifndef SERVICES_VIZ_PRIVILEGED_INTERFACES_COMPOSITING_RENDERER_SETTINGS_MOJOM_BLINK_JUMBO_H_
#define SERVICES_VIZ_PRIVILEGED_INTERFACES_COMPOSITING_RENDERER_SETTINGS_MOJOM_BLINK_JUMBO_H_
#endif
namespace viz {
namespace mojom {
namespace blink {
RendererSettings::RendererSettings()
    : allow_antialiasing(),
      force_antialiasing(),
      force_blending_with_shaders(),
      tint_gl_composited_content(),
      highp_threshold_min(),
      partial_swap_enabled(),
      release_overlay_resources_after_gpu_query(),
      should_clear_root_render_pass(),
      show_overdraw_feedback(),
      slow_down_compositing_scale_factor(),
      use_skia_renderer(),
      use_skia_renderer_non_ddl(),
      record_sk_picture(),
      allow_overlays(),
      requires_alpha_channel() {}

RendererSettings::RendererSettings(
    bool allow_antialiasing_in,
    bool force_antialiasing_in,
    bool force_blending_with_shaders_in,
    bool tint_gl_composited_content_in,
    int32_t highp_threshold_min_in,
    bool partial_swap_enabled_in,
    bool release_overlay_resources_after_gpu_query_in,
    bool should_clear_root_render_pass_in,
    bool show_overdraw_feedback_in,
    int32_t slow_down_compositing_scale_factor_in,
    bool use_skia_renderer_in,
    bool use_skia_renderer_non_ddl_in,
    bool record_sk_picture_in,
    bool allow_overlays_in,
    bool requires_alpha_channel_in)
    : allow_antialiasing(std::move(allow_antialiasing_in)),
      force_antialiasing(std::move(force_antialiasing_in)),
      force_blending_with_shaders(std::move(force_blending_with_shaders_in)),
      tint_gl_composited_content(std::move(tint_gl_composited_content_in)),
      highp_threshold_min(std::move(highp_threshold_min_in)),
      partial_swap_enabled(std::move(partial_swap_enabled_in)),
      release_overlay_resources_after_gpu_query(std::move(release_overlay_resources_after_gpu_query_in)),
      should_clear_root_render_pass(std::move(should_clear_root_render_pass_in)),
      show_overdraw_feedback(std::move(show_overdraw_feedback_in)),
      slow_down_compositing_scale_factor(std::move(slow_down_compositing_scale_factor_in)),
      use_skia_renderer(std::move(use_skia_renderer_in)),
      use_skia_renderer_non_ddl(std::move(use_skia_renderer_non_ddl_in)),
      record_sk_picture(std::move(record_sk_picture_in)),
      allow_overlays(std::move(allow_overlays_in)),
      requires_alpha_channel(std::move(requires_alpha_channel_in)) {}

RendererSettings::~RendererSettings() = default;
size_t RendererSettings::Hash(size_t seed) const {
  seed = mojo::internal::WTFHash(seed, this->allow_antialiasing);
  seed = mojo::internal::WTFHash(seed, this->force_antialiasing);
  seed = mojo::internal::WTFHash(seed, this->force_blending_with_shaders);
  seed = mojo::internal::WTFHash(seed, this->tint_gl_composited_content);
  seed = mojo::internal::WTFHash(seed, this->highp_threshold_min);
  seed = mojo::internal::WTFHash(seed, this->partial_swap_enabled);
  seed = mojo::internal::WTFHash(seed, this->release_overlay_resources_after_gpu_query);
  seed = mojo::internal::WTFHash(seed, this->should_clear_root_render_pass);
  seed = mojo::internal::WTFHash(seed, this->show_overdraw_feedback);
  seed = mojo::internal::WTFHash(seed, this->slow_down_compositing_scale_factor);
  seed = mojo::internal::WTFHash(seed, this->use_skia_renderer);
  seed = mojo::internal::WTFHash(seed, this->use_skia_renderer_non_ddl);
  seed = mojo::internal::WTFHash(seed, this->record_sk_picture);
  seed = mojo::internal::WTFHash(seed, this->allow_overlays);
  seed = mojo::internal::WTFHash(seed, this->requires_alpha_channel);
  return seed;
}

bool RendererSettings::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  return Data_::Validate(data, validation_context);
}
}  // namespace blink
}  // namespace mojom
}  // namespace viz

namespace mojo {


// static
bool StructTraits<::viz::mojom::blink::RendererSettings::DataView, ::viz::mojom::blink::RendererSettingsPtr>::Read(
    ::viz::mojom::blink::RendererSettings::DataView input,
    ::viz::mojom::blink::RendererSettingsPtr* output) {
  bool success = true;
  ::viz::mojom::blink::RendererSettingsPtr result(::viz::mojom::blink::RendererSettings::New());
  
      result->allow_antialiasing = input.allow_antialiasing();
      result->force_antialiasing = input.force_antialiasing();
      result->force_blending_with_shaders = input.force_blending_with_shaders();
      result->tint_gl_composited_content = input.tint_gl_composited_content();
      result->highp_threshold_min = input.highp_threshold_min();
      result->partial_swap_enabled = input.partial_swap_enabled();
      result->release_overlay_resources_after_gpu_query = input.release_overlay_resources_after_gpu_query();
      result->should_clear_root_render_pass = input.should_clear_root_render_pass();
      result->show_overdraw_feedback = input.show_overdraw_feedback();
      result->slow_down_compositing_scale_factor = input.slow_down_compositing_scale_factor();
      result->use_skia_renderer = input.use_skia_renderer();
      result->use_skia_renderer_non_ddl = input.use_skia_renderer_non_ddl();
      result->record_sk_picture = input.record_sk_picture();
      result->allow_overlays = input.allow_overlays();
      result->requires_alpha_channel = input.requires_alpha_channel();
  *output = std::move(result);
  return success;
}

}  // namespace mojo

#if defined(__clang__)
#pragma clang diagnostic pop
#elif defined(_MSC_VER)
#pragma warning(pop)
#endif