win-Debug/gen/content/common/media/renderer_audio_input_stream_factory.mojom-params-data.h

// Copyright 2019 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.

#ifndef CONTENT_COMMON_MEDIA_RENDERER_AUDIO_INPUT_STREAM_FACTORY_MOJOM_PARAMS_DATA_H_
#define CONTENT_COMMON_MEDIA_RENDERER_AUDIO_INPUT_STREAM_FACTORY_MOJOM_PARAMS_DATA_H_

#include "base/logging.h"
#include "base/macros.h"
#include "mojo/public/cpp/bindings/lib/bindings_internal.h"
#include "mojo/public/cpp/bindings/lib/buffer.h"
#include "mojo/public/cpp/bindings/lib/validation_context.h"

#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
namespace content {
namespace mojom {
namespace internal {
class COMPONENT_EXPORT(MOJOM_SHARED_CONTENT_EXPORT) RendererAudioInputStreamFactory_CreateStream_Params_Data {
 public:
  class BufferWriter {
   public:
    BufferWriter() = default;

    void Allocate(mojo::internal::Buffer* serialization_buffer) {
      serialization_buffer_ = serialization_buffer;
      index_ = serialization_buffer_->Allocate(sizeof(RendererAudioInputStreamFactory_CreateStream_Params_Data));
      new (data()) RendererAudioInputStreamFactory_CreateStream_Params_Data();
    }

    bool is_null() const { return !serialization_buffer_; }
    RendererAudioInputStreamFactory_CreateStream_Params_Data* data() {
      DCHECK(!is_null());
      return serialization_buffer_->Get<RendererAudioInputStreamFactory_CreateStream_Params_Data>(index_);
    }
    RendererAudioInputStreamFactory_CreateStream_Params_Data* operator->() { return data(); }

   private:
    mojo::internal::Buffer* serialization_buffer_ = nullptr;
    size_t index_ = 0;

    DISALLOW_COPY_AND_ASSIGN(BufferWriter);
  };

  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);

  mojo::internal::StructHeader header_;
  mojo::internal::Interface_Data client;
  int32_t session_id;
  uint8_t automatic_gain_control : 1;
  uint8_t pad2_[3];
  mojo::internal::Pointer<::media::mojom::internal::AudioParameters_Data> params;
  uint32_t shared_memory_count;
  uint8_t pad4_[4];
  mojo::internal::Pointer<::audio::mojom::internal::AudioProcessingConfig_Data> processing_config;

 private:
  RendererAudioInputStreamFactory_CreateStream_Params_Data();
  ~RendererAudioInputStreamFactory_CreateStream_Params_Data() = delete;
};
static_assert(sizeof(RendererAudioInputStreamFactory_CreateStream_Params_Data) == 48,
              "Bad sizeof(RendererAudioInputStreamFactory_CreateStream_Params_Data)");
class COMPONENT_EXPORT(MOJOM_SHARED_CONTENT_EXPORT) RendererAudioInputStreamFactory_AssociateInputAndOutputForAec_Params_Data {
 public:
  class BufferWriter {
   public:
    BufferWriter() = default;

    void Allocate(mojo::internal::Buffer* serialization_buffer) {
      serialization_buffer_ = serialization_buffer;
      index_ = serialization_buffer_->Allocate(sizeof(RendererAudioInputStreamFactory_AssociateInputAndOutputForAec_Params_Data));
      new (data()) RendererAudioInputStreamFactory_AssociateInputAndOutputForAec_Params_Data();
    }

    bool is_null() const { return !serialization_buffer_; }
    RendererAudioInputStreamFactory_AssociateInputAndOutputForAec_Params_Data* data() {
      DCHECK(!is_null());
      return serialization_buffer_->Get<RendererAudioInputStreamFactory_AssociateInputAndOutputForAec_Params_Data>(index_);
    }
    RendererAudioInputStreamFactory_AssociateInputAndOutputForAec_Params_Data* operator->() { return data(); }

   private:
    mojo::internal::Buffer* serialization_buffer_ = nullptr;
    size_t index_ = 0;

    DISALLOW_COPY_AND_ASSIGN(BufferWriter);
  };

  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);

  mojo::internal::StructHeader header_;
  mojo::internal::Pointer<::mojo_base::mojom::internal::UnguessableToken_Data> input_stream_id;
  mojo::internal::Pointer<mojo::internal::String_Data> output_device_id;

 private:
  RendererAudioInputStreamFactory_AssociateInputAndOutputForAec_Params_Data();
  ~RendererAudioInputStreamFactory_AssociateInputAndOutputForAec_Params_Data() = delete;
};
static_assert(sizeof(RendererAudioInputStreamFactory_AssociateInputAndOutputForAec_Params_Data) == 24,
              "Bad sizeof(RendererAudioInputStreamFactory_AssociateInputAndOutputForAec_Params_Data)");
class COMPONENT_EXPORT(MOJOM_SHARED_CONTENT_EXPORT) RendererAudioInputStreamFactoryClient_StreamCreated_Params_Data {
 public:
  class BufferWriter {
   public:
    BufferWriter() = default;

    void Allocate(mojo::internal::Buffer* serialization_buffer) {
      serialization_buffer_ = serialization_buffer;
      index_ = serialization_buffer_->Allocate(sizeof(RendererAudioInputStreamFactoryClient_StreamCreated_Params_Data));
      new (data()) RendererAudioInputStreamFactoryClient_StreamCreated_Params_Data();
    }

    bool is_null() const { return !serialization_buffer_; }
    RendererAudioInputStreamFactoryClient_StreamCreated_Params_Data* data() {
      DCHECK(!is_null());
      return serialization_buffer_->Get<RendererAudioInputStreamFactoryClient_StreamCreated_Params_Data>(index_);
    }
    RendererAudioInputStreamFactoryClient_StreamCreated_Params_Data* operator->() { return data(); }

   private:
    mojo::internal::Buffer* serialization_buffer_ = nullptr;
    size_t index_ = 0;

    DISALLOW_COPY_AND_ASSIGN(BufferWriter);
  };

  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);

  mojo::internal::StructHeader header_;
  mojo::internal::Interface_Data stream;
  mojo::internal::Handle_Data client_request;
  uint8_t initially_muted : 1;
  uint8_t pad2_[3];
  mojo::internal::Pointer<::media::mojom::internal::ReadOnlyAudioDataPipe_Data> data_pipe;
  mojo::internal::Pointer<::mojo_base::mojom::internal::UnguessableToken_Data> stream_id;

 private:
  RendererAudioInputStreamFactoryClient_StreamCreated_Params_Data();
  ~RendererAudioInputStreamFactoryClient_StreamCreated_Params_Data() = delete;
};
static_assert(sizeof(RendererAudioInputStreamFactoryClient_StreamCreated_Params_Data) == 40,
              "Bad sizeof(RendererAudioInputStreamFactoryClient_StreamCreated_Params_Data)");

}  // namespace internal
class RendererAudioInputStreamFactory_CreateStream_ParamsDataView {
 public:
  RendererAudioInputStreamFactory_CreateStream_ParamsDataView() {}

  RendererAudioInputStreamFactory_CreateStream_ParamsDataView(
      internal::RendererAudioInputStreamFactory_CreateStream_Params_Data* data,
      mojo::internal::SerializationContext* context)
      : data_(data), context_(context) {}

  bool is_null() const { return !data_; }
  template <typename UserType>
  UserType TakeClient() {
    UserType result;
    bool ret =
        mojo::internal::Deserialize<::content::mojom::RendererAudioInputStreamFactoryClientPtrDataView>(
            &data_->client, &result, context_);
    DCHECK(ret);
    return result;
  }
  int32_t session_id() const {
    return data_->session_id;
  }
  inline void GetParamsDataView(
      ::media::mojom::AudioParametersDataView* output);

  template <typename UserType>
  WARN_UNUSED_RESULT bool ReadParams(UserType* output) {
    auto* pointer = data_->params.Get();
    return mojo::internal::Deserialize<::media::mojom::AudioParametersDataView>(
        pointer, output, context_);
  }
  bool automatic_gain_control() const {
    return data_->automatic_gain_control;
  }
  uint32_t shared_memory_count() const {
    return data_->shared_memory_count;
  }
  inline void GetProcessingConfigDataView(
      ::audio::mojom::AudioProcessingConfigDataView* output);

  template <typename UserType>
  WARN_UNUSED_RESULT bool ReadProcessingConfig(UserType* output) {
    auto* pointer = data_->processing_config.Get();
    return mojo::internal::Deserialize<::audio::mojom::AudioProcessingConfigDataView>(
        pointer, output, context_);
  }
 private:
  internal::RendererAudioInputStreamFactory_CreateStream_Params_Data* data_ = nullptr;
  mojo::internal::SerializationContext* context_ = nullptr;
};

class RendererAudioInputStreamFactory_AssociateInputAndOutputForAec_ParamsDataView {
 public:
  RendererAudioInputStreamFactory_AssociateInputAndOutputForAec_ParamsDataView() {}

  RendererAudioInputStreamFactory_AssociateInputAndOutputForAec_ParamsDataView(
      internal::RendererAudioInputStreamFactory_AssociateInputAndOutputForAec_Params_Data* data,
      mojo::internal::SerializationContext* context)
      : data_(data), context_(context) {}

  bool is_null() const { return !data_; }
  inline void GetInputStreamIdDataView(
      ::mojo_base::mojom::UnguessableTokenDataView* output);

  template <typename UserType>
  WARN_UNUSED_RESULT bool ReadInputStreamId(UserType* output) {
    auto* pointer = data_->input_stream_id.Get();
    return mojo::internal::Deserialize<::mojo_base::mojom::UnguessableTokenDataView>(
        pointer, output, context_);
  }
  inline void GetOutputDeviceIdDataView(
      mojo::StringDataView* output);

  template <typename UserType>
  WARN_UNUSED_RESULT bool ReadOutputDeviceId(UserType* output) {
    auto* pointer = data_->output_device_id.Get();
    return mojo::internal::Deserialize<mojo::StringDataView>(
        pointer, output, context_);
  }
 private:
  internal::RendererAudioInputStreamFactory_AssociateInputAndOutputForAec_Params_Data* data_ = nullptr;
  mojo::internal::SerializationContext* context_ = nullptr;
};

class RendererAudioInputStreamFactoryClient_StreamCreated_ParamsDataView {
 public:
  RendererAudioInputStreamFactoryClient_StreamCreated_ParamsDataView() {}

  RendererAudioInputStreamFactoryClient_StreamCreated_ParamsDataView(
      internal::RendererAudioInputStreamFactoryClient_StreamCreated_Params_Data* data,
      mojo::internal::SerializationContext* context)
      : data_(data), context_(context) {}

  bool is_null() const { return !data_; }
  template <typename UserType>
  UserType TakeStream() {
    UserType result;
    bool ret =
        mojo::internal::Deserialize<::media::mojom::AudioInputStreamPtrDataView>(
            &data_->stream, &result, context_);
    DCHECK(ret);
    return result;
  }
  template <typename UserType>
  UserType TakeClientRequest() {
    UserType result;
    bool ret =
        mojo::internal::Deserialize<::media::mojom::AudioInputStreamClientRequestDataView>(
            &data_->client_request, &result, context_);
    DCHECK(ret);
    return result;
  }
  inline void GetDataPipeDataView(
      ::media::mojom::ReadOnlyAudioDataPipeDataView* output);

  template <typename UserType>
  WARN_UNUSED_RESULT bool ReadDataPipe(UserType* output) {
    auto* pointer = data_->data_pipe.Get();
    return mojo::internal::Deserialize<::media::mojom::ReadOnlyAudioDataPipeDataView>(
        pointer, output, context_);
  }
  bool initially_muted() const {
    return data_->initially_muted;
  }
  inline void GetStreamIdDataView(
      ::mojo_base::mojom::UnguessableTokenDataView* output);

  template <typename UserType>
  WARN_UNUSED_RESULT bool ReadStreamId(UserType* output) {
    auto* pointer = data_->stream_id.Get();
    return mojo::internal::Deserialize<::mojo_base::mojom::UnguessableTokenDataView>(
        pointer, output, context_);
  }
 private:
  internal::RendererAudioInputStreamFactoryClient_StreamCreated_Params_Data* data_ = nullptr;
  mojo::internal::SerializationContext* context_ = nullptr;
};


inline void RendererAudioInputStreamFactory_CreateStream_ParamsDataView::GetParamsDataView(
    ::media::mojom::AudioParametersDataView* output) {
  auto pointer = data_->params.Get();
  *output = ::media::mojom::AudioParametersDataView(pointer, context_);
}
inline void RendererAudioInputStreamFactory_CreateStream_ParamsDataView::GetProcessingConfigDataView(
    ::audio::mojom::AudioProcessingConfigDataView* output) {
  auto pointer = data_->processing_config.Get();
  *output = ::audio::mojom::AudioProcessingConfigDataView(pointer, context_);
}


inline void RendererAudioInputStreamFactory_AssociateInputAndOutputForAec_ParamsDataView::GetInputStreamIdDataView(
    ::mojo_base::mojom::UnguessableTokenDataView* output) {
  auto pointer = data_->input_stream_id.Get();
  *output = ::mojo_base::mojom::UnguessableTokenDataView(pointer, context_);
}
inline void RendererAudioInputStreamFactory_AssociateInputAndOutputForAec_ParamsDataView::GetOutputDeviceIdDataView(
    mojo::StringDataView* output) {
  auto pointer = data_->output_device_id.Get();
  *output = mojo::StringDataView(pointer, context_);
}


inline void RendererAudioInputStreamFactoryClient_StreamCreated_ParamsDataView::GetDataPipeDataView(
    ::media::mojom::ReadOnlyAudioDataPipeDataView* output) {
  auto pointer = data_->data_pipe.Get();
  *output = ::media::mojom::ReadOnlyAudioDataPipeDataView(pointer, context_);
}
inline void RendererAudioInputStreamFactoryClient_StreamCreated_ParamsDataView::GetStreamIdDataView(
    ::mojo_base::mojom::UnguessableTokenDataView* output) {
  auto pointer = data_->stream_id.Get();
  *output = ::mojo_base::mojom::UnguessableTokenDataView(pointer, context_);
}

}  // namespace mojom
}  // namespace content

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

#endif  // CONTENT_COMMON_MEDIA_RENDERER_AUDIO_INPUT_STREAM_FACTORY_MOJOM_PARAMS_DATA_H_