win-Debug/gen/content/common/renderer.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_RENDERER_MOJOM_PARAMS_DATA_H_
#define CONTENT_COMMON_RENDERER_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) Renderer_CreateEmbedderRendererService_Params_Data {
 public:
  class BufferWriter {
   public:
    BufferWriter() = default;

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

    bool is_null() const { return !serialization_buffer_; }
    Renderer_CreateEmbedderRendererService_Params_Data* data() {
      DCHECK(!is_null());
      return serialization_buffer_->Get<Renderer_CreateEmbedderRendererService_Params_Data>(index_);
    }
    Renderer_CreateEmbedderRendererService_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::Handle_Data service_request;
  uint8_t padfinal_[4];

 private:
  Renderer_CreateEmbedderRendererService_Params_Data();
  ~Renderer_CreateEmbedderRendererService_Params_Data() = delete;
};
static_assert(sizeof(Renderer_CreateEmbedderRendererService_Params_Data) == 16,
              "Bad sizeof(Renderer_CreateEmbedderRendererService_Params_Data)");
class COMPONENT_EXPORT(MOJOM_SHARED_CONTENT_EXPORT) Renderer_CreateView_Params_Data {
 public:
  class BufferWriter {
   public:
    BufferWriter() = default;

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

    bool is_null() const { return !serialization_buffer_; }
    Renderer_CreateView_Params_Data* data() {
      DCHECK(!is_null());
      return serialization_buffer_->Get<Renderer_CreateView_Params_Data>(index_);
    }
    Renderer_CreateView_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<internal::CreateViewParams_Data> params;

 private:
  Renderer_CreateView_Params_Data();
  ~Renderer_CreateView_Params_Data() = delete;
};
static_assert(sizeof(Renderer_CreateView_Params_Data) == 16,
              "Bad sizeof(Renderer_CreateView_Params_Data)");
class COMPONENT_EXPORT(MOJOM_SHARED_CONTENT_EXPORT) Renderer_CreateFrame_Params_Data {
 public:
  class BufferWriter {
   public:
    BufferWriter() = default;

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

    bool is_null() const { return !serialization_buffer_; }
    Renderer_CreateFrame_Params_Data* data() {
      DCHECK(!is_null());
      return serialization_buffer_->Get<Renderer_CreateFrame_Params_Data>(index_);
    }
    Renderer_CreateFrame_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<internal::CreateFrameParams_Data> params;

 private:
  Renderer_CreateFrame_Params_Data();
  ~Renderer_CreateFrame_Params_Data() = delete;
};
static_assert(sizeof(Renderer_CreateFrame_Params_Data) == 16,
              "Bad sizeof(Renderer_CreateFrame_Params_Data)");
class COMPONENT_EXPORT(MOJOM_SHARED_CONTENT_EXPORT) Renderer_CreateFrameProxy_Params_Data {
 public:
  class BufferWriter {
   public:
    BufferWriter() = default;

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

    bool is_null() const { return !serialization_buffer_; }
    Renderer_CreateFrameProxy_Params_Data* data() {
      DCHECK(!is_null());
      return serialization_buffer_->Get<Renderer_CreateFrameProxy_Params_Data>(index_);
    }
    Renderer_CreateFrameProxy_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_;
  int32_t routing_id;
  int32_t render_view_routing_id;
  int32_t opener_routing_id;
  int32_t parent_routing_id;
  mojo::internal::Pointer<::content::mojom::internal::FrameReplicationState_Data> replication_state;
  mojo::internal::Pointer<::mojo_base::mojom::internal::UnguessableToken_Data> devtools_frame_token;

 private:
  Renderer_CreateFrameProxy_Params_Data();
  ~Renderer_CreateFrameProxy_Params_Data() = delete;
};
static_assert(sizeof(Renderer_CreateFrameProxy_Params_Data) == 40,
              "Bad sizeof(Renderer_CreateFrameProxy_Params_Data)");
class COMPONENT_EXPORT(MOJOM_SHARED_CONTENT_EXPORT) Renderer_SetUpEmbeddedWorkerChannelForServiceWorker_Params_Data {
 public:
  class BufferWriter {
   public:
    BufferWriter() = default;

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

    bool is_null() const { return !serialization_buffer_; }
    Renderer_SetUpEmbeddedWorkerChannelForServiceWorker_Params_Data* data() {
      DCHECK(!is_null());
      return serialization_buffer_->Get<Renderer_SetUpEmbeddedWorkerChannelForServiceWorker_Params_Data>(index_);
    }
    Renderer_SetUpEmbeddedWorkerChannelForServiceWorker_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::Handle_Data client_request;
  uint8_t padfinal_[4];

 private:
  Renderer_SetUpEmbeddedWorkerChannelForServiceWorker_Params_Data();
  ~Renderer_SetUpEmbeddedWorkerChannelForServiceWorker_Params_Data() = delete;
};
static_assert(sizeof(Renderer_SetUpEmbeddedWorkerChannelForServiceWorker_Params_Data) == 16,
              "Bad sizeof(Renderer_SetUpEmbeddedWorkerChannelForServiceWorker_Params_Data)");
class COMPONENT_EXPORT(MOJOM_SHARED_CONTENT_EXPORT) Renderer_OnNetworkConnectionChanged_Params_Data {
 public:
  class BufferWriter {
   public:
    BufferWriter() = default;

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

    bool is_null() const { return !serialization_buffer_; }
    Renderer_OnNetworkConnectionChanged_Params_Data* data() {
      DCHECK(!is_null());
      return serialization_buffer_->Get<Renderer_OnNetworkConnectionChanged_Params_Data>(index_);
    }
    Renderer_OnNetworkConnectionChanged_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_;
  int32_t connection_type;
  uint8_t pad0_[4];
  double max_bandwidth_mbps;

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

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

    bool is_null() const { return !serialization_buffer_; }
    Renderer_OnNetworkQualityChanged_Params_Data* data() {
      DCHECK(!is_null());
      return serialization_buffer_->Get<Renderer_OnNetworkQualityChanged_Params_Data>(index_);
    }
    Renderer_OnNetworkQualityChanged_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_;
  int32_t effective_connection_type;
  uint8_t pad0_[4];
  mojo::internal::Pointer<::mojo_base::mojom::internal::TimeDelta_Data> http_rtt;
  mojo::internal::Pointer<::mojo_base::mojom::internal::TimeDelta_Data> transport_rtt;
  double bandwidth_kbps;

 private:
  Renderer_OnNetworkQualityChanged_Params_Data();
  ~Renderer_OnNetworkQualityChanged_Params_Data() = delete;
};
static_assert(sizeof(Renderer_OnNetworkQualityChanged_Params_Data) == 40,
              "Bad sizeof(Renderer_OnNetworkQualityChanged_Params_Data)");
class COMPONENT_EXPORT(MOJOM_SHARED_CONTENT_EXPORT) Renderer_SetWebKitSharedTimersSuspended_Params_Data {
 public:
  class BufferWriter {
   public:
    BufferWriter() = default;

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

    bool is_null() const { return !serialization_buffer_; }
    Renderer_SetWebKitSharedTimersSuspended_Params_Data* data() {
      DCHECK(!is_null());
      return serialization_buffer_->Get<Renderer_SetWebKitSharedTimersSuspended_Params_Data>(index_);
    }
    Renderer_SetWebKitSharedTimersSuspended_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_;
  uint8_t suspend : 1;
  uint8_t padfinal_[7];

 private:
  Renderer_SetWebKitSharedTimersSuspended_Params_Data();
  ~Renderer_SetWebKitSharedTimersSuspended_Params_Data() = delete;
};
static_assert(sizeof(Renderer_SetWebKitSharedTimersSuspended_Params_Data) == 16,
              "Bad sizeof(Renderer_SetWebKitSharedTimersSuspended_Params_Data)");
class COMPONENT_EXPORT(MOJOM_SHARED_CONTENT_EXPORT) Renderer_SetUserAgent_Params_Data {
 public:
  class BufferWriter {
   public:
    BufferWriter() = default;

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

    bool is_null() const { return !serialization_buffer_; }
    Renderer_SetUserAgent_Params_Data* data() {
      DCHECK(!is_null());
      return serialization_buffer_->Get<Renderer_SetUserAgent_Params_Data>(index_);
    }
    Renderer_SetUserAgent_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::internal::String_Data> user_agent;

 private:
  Renderer_SetUserAgent_Params_Data();
  ~Renderer_SetUserAgent_Params_Data() = delete;
};
static_assert(sizeof(Renderer_SetUserAgent_Params_Data) == 16,
              "Bad sizeof(Renderer_SetUserAgent_Params_Data)");
class COMPONENT_EXPORT(MOJOM_SHARED_CONTENT_EXPORT) Renderer_SetUserAgentMetadata_Params_Data {
 public:
  class BufferWriter {
   public:
    BufferWriter() = default;

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

    bool is_null() const { return !serialization_buffer_; }
    Renderer_SetUserAgentMetadata_Params_Data* data() {
      DCHECK(!is_null());
      return serialization_buffer_->Get<Renderer_SetUserAgentMetadata_Params_Data>(index_);
    }
    Renderer_SetUserAgentMetadata_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<::blink::mojom::internal::UserAgentMetadata_Data> metadata;

 private:
  Renderer_SetUserAgentMetadata_Params_Data();
  ~Renderer_SetUserAgentMetadata_Params_Data() = delete;
};
static_assert(sizeof(Renderer_SetUserAgentMetadata_Params_Data) == 16,
              "Bad sizeof(Renderer_SetUserAgentMetadata_Params_Data)");
class COMPONENT_EXPORT(MOJOM_SHARED_CONTENT_EXPORT) Renderer_UpdateScrollbarTheme_Params_Data {
 public:
  class BufferWriter {
   public:
    BufferWriter() = default;

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

    bool is_null() const { return !serialization_buffer_; }
    Renderer_UpdateScrollbarTheme_Params_Data* data() {
      DCHECK(!is_null());
      return serialization_buffer_->Get<Renderer_UpdateScrollbarTheme_Params_Data>(index_);
    }
    Renderer_UpdateScrollbarTheme_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<internal::UpdateScrollbarThemeParams_Data> params;

 private:
  Renderer_UpdateScrollbarTheme_Params_Data();
  ~Renderer_UpdateScrollbarTheme_Params_Data() = delete;
};
static_assert(sizeof(Renderer_UpdateScrollbarTheme_Params_Data) == 16,
              "Bad sizeof(Renderer_UpdateScrollbarTheme_Params_Data)");
class COMPONENT_EXPORT(MOJOM_SHARED_CONTENT_EXPORT) Renderer_OnSystemColorsChanged_Params_Data {
 public:
  class BufferWriter {
   public:
    BufferWriter() = default;

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

    bool is_null() const { return !serialization_buffer_; }
    Renderer_OnSystemColorsChanged_Params_Data* data() {
      DCHECK(!is_null());
      return serialization_buffer_->Get<Renderer_OnSystemColorsChanged_Params_Data>(index_);
    }
    Renderer_OnSystemColorsChanged_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_;
  int32_t aqua_color_variant;
  uint8_t pad0_[4];
  mojo::internal::Pointer<mojo::internal::String_Data> highlight_text_color;
  mojo::internal::Pointer<mojo::internal::String_Data> highlight_color;

 private:
  Renderer_OnSystemColorsChanged_Params_Data();
  ~Renderer_OnSystemColorsChanged_Params_Data() = delete;
};
static_assert(sizeof(Renderer_OnSystemColorsChanged_Params_Data) == 32,
              "Bad sizeof(Renderer_OnSystemColorsChanged_Params_Data)");
class COMPONENT_EXPORT(MOJOM_SHARED_CONTENT_EXPORT) Renderer_PurgePluginListCache_Params_Data {
 public:
  class BufferWriter {
   public:
    BufferWriter() = default;

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

    bool is_null() const { return !serialization_buffer_; }
    Renderer_PurgePluginListCache_Params_Data* data() {
      DCHECK(!is_null());
      return serialization_buffer_->Get<Renderer_PurgePluginListCache_Params_Data>(index_);
    }
    Renderer_PurgePluginListCache_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_;
  uint8_t reload_pages : 1;
  uint8_t padfinal_[7];

 private:
  Renderer_PurgePluginListCache_Params_Data();
  ~Renderer_PurgePluginListCache_Params_Data() = delete;
};
static_assert(sizeof(Renderer_PurgePluginListCache_Params_Data) == 16,
              "Bad sizeof(Renderer_PurgePluginListCache_Params_Data)");
class COMPONENT_EXPORT(MOJOM_SHARED_CONTENT_EXPORT) Renderer_SetProcessState_Params_Data {
 public:
  class BufferWriter {
   public:
    BufferWriter() = default;

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

    bool is_null() const { return !serialization_buffer_; }
    Renderer_SetProcessState_Params_Data* data() {
      DCHECK(!is_null());
      return serialization_buffer_->Get<Renderer_SetProcessState_Params_Data>(index_);
    }
    Renderer_SetProcessState_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_;
  int32_t process_state;
  uint8_t padfinal_[4];

 private:
  Renderer_SetProcessState_Params_Data();
  ~Renderer_SetProcessState_Params_Data() = delete;
};
static_assert(sizeof(Renderer_SetProcessState_Params_Data) == 16,
              "Bad sizeof(Renderer_SetProcessState_Params_Data)");
class COMPONENT_EXPORT(MOJOM_SHARED_CONTENT_EXPORT) Renderer_SetSchedulerKeepActive_Params_Data {
 public:
  class BufferWriter {
   public:
    BufferWriter() = default;

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

    bool is_null() const { return !serialization_buffer_; }
    Renderer_SetSchedulerKeepActive_Params_Data* data() {
      DCHECK(!is_null());
      return serialization_buffer_->Get<Renderer_SetSchedulerKeepActive_Params_Data>(index_);
    }
    Renderer_SetSchedulerKeepActive_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_;
  uint8_t keep_active : 1;
  uint8_t padfinal_[7];

 private:
  Renderer_SetSchedulerKeepActive_Params_Data();
  ~Renderer_SetSchedulerKeepActive_Params_Data() = delete;
};
static_assert(sizeof(Renderer_SetSchedulerKeepActive_Params_Data) == 16,
              "Bad sizeof(Renderer_SetSchedulerKeepActive_Params_Data)");
class COMPONENT_EXPORT(MOJOM_SHARED_CONTENT_EXPORT) Renderer_SetIsLockedToSite_Params_Data {
 public:
  class BufferWriter {
   public:
    BufferWriter() = default;

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

    bool is_null() const { return !serialization_buffer_; }
    Renderer_SetIsLockedToSite_Params_Data* data() {
      DCHECK(!is_null());
      return serialization_buffer_->Get<Renderer_SetIsLockedToSite_Params_Data>(index_);
    }
    Renderer_SetIsLockedToSite_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_;

 private:
  Renderer_SetIsLockedToSite_Params_Data();
  ~Renderer_SetIsLockedToSite_Params_Data() = delete;
};
static_assert(sizeof(Renderer_SetIsLockedToSite_Params_Data) == 8,
              "Bad sizeof(Renderer_SetIsLockedToSite_Params_Data)");
class COMPONENT_EXPORT(MOJOM_SHARED_CONTENT_EXPORT) Renderer_EnableV8LowMemoryMode_Params_Data {
 public:
  class BufferWriter {
   public:
    BufferWriter() = default;

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

    bool is_null() const { return !serialization_buffer_; }
    Renderer_EnableV8LowMemoryMode_Params_Data* data() {
      DCHECK(!is_null());
      return serialization_buffer_->Get<Renderer_EnableV8LowMemoryMode_Params_Data>(index_);
    }
    Renderer_EnableV8LowMemoryMode_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_;

 private:
  Renderer_EnableV8LowMemoryMode_Params_Data();
  ~Renderer_EnableV8LowMemoryMode_Params_Data() = delete;
};
static_assert(sizeof(Renderer_EnableV8LowMemoryMode_Params_Data) == 8,
              "Bad sizeof(Renderer_EnableV8LowMemoryMode_Params_Data)");

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

  Renderer_CreateEmbedderRendererService_ParamsDataView(
      internal::Renderer_CreateEmbedderRendererService_Params_Data* data,
      mojo::internal::SerializationContext* context)
      : data_(data), context_(context) {}

  bool is_null() const { return !data_; }
  template <typename UserType>
  UserType TakeServiceRequest() {
    UserType result;
    bool ret =
        mojo::internal::Deserialize<::service_manager::mojom::ServiceRequestDataView>(
            &data_->service_request, &result, context_);
    DCHECK(ret);
    return result;
  }
 private:
  internal::Renderer_CreateEmbedderRendererService_Params_Data* data_ = nullptr;
  mojo::internal::SerializationContext* context_ = nullptr;
};

class Renderer_CreateView_ParamsDataView {
 public:
  Renderer_CreateView_ParamsDataView() {}

  Renderer_CreateView_ParamsDataView(
      internal::Renderer_CreateView_Params_Data* data,
      mojo::internal::SerializationContext* context)
      : data_(data), context_(context) {}

  bool is_null() const { return !data_; }
  inline void GetParamsDataView(
      CreateViewParamsDataView* output);

  template <typename UserType>
  WARN_UNUSED_RESULT bool ReadParams(UserType* output) {
    auto* pointer = data_->params.Get();
    return mojo::internal::Deserialize<::content::mojom::CreateViewParamsDataView>(
        pointer, output, context_);
  }
 private:
  internal::Renderer_CreateView_Params_Data* data_ = nullptr;
  mojo::internal::SerializationContext* context_ = nullptr;
};

class Renderer_CreateFrame_ParamsDataView {
 public:
  Renderer_CreateFrame_ParamsDataView() {}

  Renderer_CreateFrame_ParamsDataView(
      internal::Renderer_CreateFrame_Params_Data* data,
      mojo::internal::SerializationContext* context)
      : data_(data), context_(context) {}

  bool is_null() const { return !data_; }
  inline void GetParamsDataView(
      CreateFrameParamsDataView* output);

  template <typename UserType>
  WARN_UNUSED_RESULT bool ReadParams(UserType* output) {
    auto* pointer = data_->params.Get();
    return mojo::internal::Deserialize<::content::mojom::CreateFrameParamsDataView>(
        pointer, output, context_);
  }
 private:
  internal::Renderer_CreateFrame_Params_Data* data_ = nullptr;
  mojo::internal::SerializationContext* context_ = nullptr;
};

class Renderer_CreateFrameProxy_ParamsDataView {
 public:
  Renderer_CreateFrameProxy_ParamsDataView() {}

  Renderer_CreateFrameProxy_ParamsDataView(
      internal::Renderer_CreateFrameProxy_Params_Data* data,
      mojo::internal::SerializationContext* context)
      : data_(data), context_(context) {}

  bool is_null() const { return !data_; }
  int32_t routing_id() const {
    return data_->routing_id;
  }
  int32_t render_view_routing_id() const {
    return data_->render_view_routing_id;
  }
  int32_t opener_routing_id() const {
    return data_->opener_routing_id;
  }
  int32_t parent_routing_id() const {
    return data_->parent_routing_id;
  }
  inline void GetReplicationStateDataView(
      ::content::mojom::FrameReplicationStateDataView* output);

  template <typename UserType>
  WARN_UNUSED_RESULT bool ReadReplicationState(UserType* output) {
    auto* pointer = data_->replication_state.Get();
    return mojo::internal::Deserialize<::content::mojom::FrameReplicationStateDataView>(
        pointer, output, context_);
  }
  inline void GetDevtoolsFrameTokenDataView(
      ::mojo_base::mojom::UnguessableTokenDataView* output);

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

class Renderer_SetUpEmbeddedWorkerChannelForServiceWorker_ParamsDataView {
 public:
  Renderer_SetUpEmbeddedWorkerChannelForServiceWorker_ParamsDataView() {}

  Renderer_SetUpEmbeddedWorkerChannelForServiceWorker_ParamsDataView(
      internal::Renderer_SetUpEmbeddedWorkerChannelForServiceWorker_Params_Data* data,
      mojo::internal::SerializationContext* context)
      : data_(data), context_(context) {}

  bool is_null() const { return !data_; }
  template <typename UserType>
  UserType TakeClientRequest() {
    UserType result;
    bool ret =
        mojo::internal::Deserialize<::blink::mojom::EmbeddedWorkerInstanceClientRequestDataView>(
            &data_->client_request, &result, context_);
    DCHECK(ret);
    return result;
  }
 private:
  internal::Renderer_SetUpEmbeddedWorkerChannelForServiceWorker_Params_Data* data_ = nullptr;
  mojo::internal::SerializationContext* context_ = nullptr;
};

class Renderer_OnNetworkConnectionChanged_ParamsDataView {
 public:
  Renderer_OnNetworkConnectionChanged_ParamsDataView() {}

  Renderer_OnNetworkConnectionChanged_ParamsDataView(
      internal::Renderer_OnNetworkConnectionChanged_Params_Data* data,
      mojo::internal::SerializationContext* context)
      : data_(data) {}

  bool is_null() const { return !data_; }
  template <typename UserType>
  WARN_UNUSED_RESULT bool ReadConnectionType(UserType* output) const {
    auto data_value = data_->connection_type;
    return mojo::internal::Deserialize<::content::mojom::NetworkConnectionType>(
        data_value, output);
  }

  ::content::mojom::NetworkConnectionType connection_type() const {
    return static_cast<::content::mojom::NetworkConnectionType>(data_->connection_type);
  }
  double max_bandwidth_mbps() const {
    return data_->max_bandwidth_mbps;
  }
 private:
  internal::Renderer_OnNetworkConnectionChanged_Params_Data* data_ = nullptr;
};

class Renderer_OnNetworkQualityChanged_ParamsDataView {
 public:
  Renderer_OnNetworkQualityChanged_ParamsDataView() {}

  Renderer_OnNetworkQualityChanged_ParamsDataView(
      internal::Renderer_OnNetworkQualityChanged_Params_Data* data,
      mojo::internal::SerializationContext* context)
      : data_(data), context_(context) {}

  bool is_null() const { return !data_; }
  template <typename UserType>
  WARN_UNUSED_RESULT bool ReadEffectiveConnectionType(UserType* output) const {
    auto data_value = data_->effective_connection_type;
    return mojo::internal::Deserialize<::network::mojom::EffectiveConnectionType>(
        data_value, output);
  }

  ::network::mojom::EffectiveConnectionType effective_connection_type() const {
    return static_cast<::network::mojom::EffectiveConnectionType>(data_->effective_connection_type);
  }
  inline void GetHttpRttDataView(
      ::mojo_base::mojom::TimeDeltaDataView* output);

  template <typename UserType>
  WARN_UNUSED_RESULT bool ReadHttpRtt(UserType* output) {
    auto* pointer = data_->http_rtt.Get();
    return mojo::internal::Deserialize<::mojo_base::mojom::TimeDeltaDataView>(
        pointer, output, context_);
  }
  inline void GetTransportRttDataView(
      ::mojo_base::mojom::TimeDeltaDataView* output);

  template <typename UserType>
  WARN_UNUSED_RESULT bool ReadTransportRtt(UserType* output) {
    auto* pointer = data_->transport_rtt.Get();
    return mojo::internal::Deserialize<::mojo_base::mojom::TimeDeltaDataView>(
        pointer, output, context_);
  }
  double bandwidth_kbps() const {
    return data_->bandwidth_kbps;
  }
 private:
  internal::Renderer_OnNetworkQualityChanged_Params_Data* data_ = nullptr;
  mojo::internal::SerializationContext* context_ = nullptr;
};

class Renderer_SetWebKitSharedTimersSuspended_ParamsDataView {
 public:
  Renderer_SetWebKitSharedTimersSuspended_ParamsDataView() {}

  Renderer_SetWebKitSharedTimersSuspended_ParamsDataView(
      internal::Renderer_SetWebKitSharedTimersSuspended_Params_Data* data,
      mojo::internal::SerializationContext* context)
      : data_(data) {}

  bool is_null() const { return !data_; }
  bool suspend() const {
    return data_->suspend;
  }
 private:
  internal::Renderer_SetWebKitSharedTimersSuspended_Params_Data* data_ = nullptr;
};

class Renderer_SetUserAgent_ParamsDataView {
 public:
  Renderer_SetUserAgent_ParamsDataView() {}

  Renderer_SetUserAgent_ParamsDataView(
      internal::Renderer_SetUserAgent_Params_Data* data,
      mojo::internal::SerializationContext* context)
      : data_(data), context_(context) {}

  bool is_null() const { return !data_; }
  inline void GetUserAgentDataView(
      mojo::StringDataView* output);

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

class Renderer_SetUserAgentMetadata_ParamsDataView {
 public:
  Renderer_SetUserAgentMetadata_ParamsDataView() {}

  Renderer_SetUserAgentMetadata_ParamsDataView(
      internal::Renderer_SetUserAgentMetadata_Params_Data* data,
      mojo::internal::SerializationContext* context)
      : data_(data), context_(context) {}

  bool is_null() const { return !data_; }
  inline void GetMetadataDataView(
      ::blink::mojom::UserAgentMetadataDataView* output);

  template <typename UserType>
  WARN_UNUSED_RESULT bool ReadMetadata(UserType* output) {
    auto* pointer = data_->metadata.Get();
    return mojo::internal::Deserialize<::blink::mojom::UserAgentMetadataDataView>(
        pointer, output, context_);
  }
 private:
  internal::Renderer_SetUserAgentMetadata_Params_Data* data_ = nullptr;
  mojo::internal::SerializationContext* context_ = nullptr;
};

class Renderer_UpdateScrollbarTheme_ParamsDataView {
 public:
  Renderer_UpdateScrollbarTheme_ParamsDataView() {}

  Renderer_UpdateScrollbarTheme_ParamsDataView(
      internal::Renderer_UpdateScrollbarTheme_Params_Data* data,
      mojo::internal::SerializationContext* context)
      : data_(data), context_(context) {}

  bool is_null() const { return !data_; }
  inline void GetParamsDataView(
      UpdateScrollbarThemeParamsDataView* output);

  template <typename UserType>
  WARN_UNUSED_RESULT bool ReadParams(UserType* output) {
    auto* pointer = data_->params.Get();
    return mojo::internal::Deserialize<::content::mojom::UpdateScrollbarThemeParamsDataView>(
        pointer, output, context_);
  }
 private:
  internal::Renderer_UpdateScrollbarTheme_Params_Data* data_ = nullptr;
  mojo::internal::SerializationContext* context_ = nullptr;
};

class Renderer_OnSystemColorsChanged_ParamsDataView {
 public:
  Renderer_OnSystemColorsChanged_ParamsDataView() {}

  Renderer_OnSystemColorsChanged_ParamsDataView(
      internal::Renderer_OnSystemColorsChanged_Params_Data* data,
      mojo::internal::SerializationContext* context)
      : data_(data), context_(context) {}

  bool is_null() const { return !data_; }
  int32_t aqua_color_variant() const {
    return data_->aqua_color_variant;
  }
  inline void GetHighlightTextColorDataView(
      mojo::StringDataView* output);

  template <typename UserType>
  WARN_UNUSED_RESULT bool ReadHighlightTextColor(UserType* output) {
    auto* pointer = data_->highlight_text_color.Get();
    return mojo::internal::Deserialize<mojo::StringDataView>(
        pointer, output, context_);
  }
  inline void GetHighlightColorDataView(
      mojo::StringDataView* output);

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

class Renderer_PurgePluginListCache_ParamsDataView {
 public:
  Renderer_PurgePluginListCache_ParamsDataView() {}

  Renderer_PurgePluginListCache_ParamsDataView(
      internal::Renderer_PurgePluginListCache_Params_Data* data,
      mojo::internal::SerializationContext* context)
      : data_(data) {}

  bool is_null() const { return !data_; }
  bool reload_pages() const {
    return data_->reload_pages;
  }
 private:
  internal::Renderer_PurgePluginListCache_Params_Data* data_ = nullptr;
};

class Renderer_SetProcessState_ParamsDataView {
 public:
  Renderer_SetProcessState_ParamsDataView() {}

  Renderer_SetProcessState_ParamsDataView(
      internal::Renderer_SetProcessState_Params_Data* data,
      mojo::internal::SerializationContext* context)
      : data_(data) {}

  bool is_null() const { return !data_; }
  template <typename UserType>
  WARN_UNUSED_RESULT bool ReadProcessState(UserType* output) const {
    auto data_value = data_->process_state;
    return mojo::internal::Deserialize<::content::mojom::RenderProcessState>(
        data_value, output);
  }

  RenderProcessState process_state() const {
    return static_cast<RenderProcessState>(data_->process_state);
  }
 private:
  internal::Renderer_SetProcessState_Params_Data* data_ = nullptr;
};

class Renderer_SetSchedulerKeepActive_ParamsDataView {
 public:
  Renderer_SetSchedulerKeepActive_ParamsDataView() {}

  Renderer_SetSchedulerKeepActive_ParamsDataView(
      internal::Renderer_SetSchedulerKeepActive_Params_Data* data,
      mojo::internal::SerializationContext* context)
      : data_(data) {}

  bool is_null() const { return !data_; }
  bool keep_active() const {
    return data_->keep_active;
  }
 private:
  internal::Renderer_SetSchedulerKeepActive_Params_Data* data_ = nullptr;
};

class Renderer_SetIsLockedToSite_ParamsDataView {
 public:
  Renderer_SetIsLockedToSite_ParamsDataView() {}

  Renderer_SetIsLockedToSite_ParamsDataView(
      internal::Renderer_SetIsLockedToSite_Params_Data* data,
      mojo::internal::SerializationContext* context)
      : data_(data) {}

  bool is_null() const { return !data_; }
 private:
  internal::Renderer_SetIsLockedToSite_Params_Data* data_ = nullptr;
};

class Renderer_EnableV8LowMemoryMode_ParamsDataView {
 public:
  Renderer_EnableV8LowMemoryMode_ParamsDataView() {}

  Renderer_EnableV8LowMemoryMode_ParamsDataView(
      internal::Renderer_EnableV8LowMemoryMode_Params_Data* data,
      mojo::internal::SerializationContext* context)
      : data_(data) {}

  bool is_null() const { return !data_; }
 private:
  internal::Renderer_EnableV8LowMemoryMode_Params_Data* data_ = nullptr;
};




inline void Renderer_CreateView_ParamsDataView::GetParamsDataView(
    CreateViewParamsDataView* output) {
  auto pointer = data_->params.Get();
  *output = CreateViewParamsDataView(pointer, context_);
}


inline void Renderer_CreateFrame_ParamsDataView::GetParamsDataView(
    CreateFrameParamsDataView* output) {
  auto pointer = data_->params.Get();
  *output = CreateFrameParamsDataView(pointer, context_);
}


inline void Renderer_CreateFrameProxy_ParamsDataView::GetReplicationStateDataView(
    ::content::mojom::FrameReplicationStateDataView* output) {
  auto pointer = data_->replication_state.Get();
  *output = ::content::mojom::FrameReplicationStateDataView(pointer, context_);
}
inline void Renderer_CreateFrameProxy_ParamsDataView::GetDevtoolsFrameTokenDataView(
    ::mojo_base::mojom::UnguessableTokenDataView* output) {
  auto pointer = data_->devtools_frame_token.Get();
  *output = ::mojo_base::mojom::UnguessableTokenDataView(pointer, context_);
}






inline void Renderer_OnNetworkQualityChanged_ParamsDataView::GetHttpRttDataView(
    ::mojo_base::mojom::TimeDeltaDataView* output) {
  auto pointer = data_->http_rtt.Get();
  *output = ::mojo_base::mojom::TimeDeltaDataView(pointer, context_);
}
inline void Renderer_OnNetworkQualityChanged_ParamsDataView::GetTransportRttDataView(
    ::mojo_base::mojom::TimeDeltaDataView* output) {
  auto pointer = data_->transport_rtt.Get();
  *output = ::mojo_base::mojom::TimeDeltaDataView(pointer, context_);
}




inline void Renderer_SetUserAgent_ParamsDataView::GetUserAgentDataView(
    mojo::StringDataView* output) {
  auto pointer = data_->user_agent.Get();
  *output = mojo::StringDataView(pointer, context_);
}


inline void Renderer_SetUserAgentMetadata_ParamsDataView::GetMetadataDataView(
    ::blink::mojom::UserAgentMetadataDataView* output) {
  auto pointer = data_->metadata.Get();
  *output = ::blink::mojom::UserAgentMetadataDataView(pointer, context_);
}


inline void Renderer_UpdateScrollbarTheme_ParamsDataView::GetParamsDataView(
    UpdateScrollbarThemeParamsDataView* output) {
  auto pointer = data_->params.Get();
  *output = UpdateScrollbarThemeParamsDataView(pointer, context_);
}


inline void Renderer_OnSystemColorsChanged_ParamsDataView::GetHighlightTextColorDataView(
    mojo::StringDataView* output) {
  auto pointer = data_->highlight_text_color.Get();
  *output = mojo::StringDataView(pointer, context_);
}
inline void Renderer_OnSystemColorsChanged_ParamsDataView::GetHighlightColorDataView(
    mojo::StringDataView* output) {
  auto pointer = data_->highlight_color.Get();
  *output = mojo::StringDataView(pointer, context_);
}











}  // namespace mojom
}  // namespace content

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

#endif  // CONTENT_COMMON_RENDERER_MOJOM_PARAMS_DATA_H_