Debug/gen/services/ui/public/interfaces/window_manager.mojom-shared-internal.h

// Copyright 2016 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 SERVICES_UI_PUBLIC_INTERFACES_WINDOW_MANAGER_MOJOM_SHARED_INTERNAL_H_
#define SERVICES_UI_PUBLIC_INTERFACES_WINDOW_MANAGER_MOJOM_SHARED_INTERNAL_H_

#include <stdint.h>

#include "mojo/public/cpp/bindings/lib/array_internal.h"
#include "mojo/public/cpp/bindings/lib/bindings_internal.h"
#include "mojo/public/cpp/bindings/lib/map_data_internal.h"
#include "mojo/public/cpp/bindings/lib/native_enum_data.h"
#include "mojo/public/cpp/bindings/lib/native_struct_data.h"
#include "mojo/public/cpp/bindings/lib/buffer.h"
#include "cc/ipc/frame_sink_id.mojom-shared-internal.h"
#include "cc/ipc/local_surface_id.mojom-shared-internal.h"
#include "services/ui/public/interfaces/cursor/cursor.mojom-shared-internal.h"
#include "services/ui/public/interfaces/event_matcher.mojom-shared-internal.h"
#include "services/ui/public/interfaces/window_manager_constants.mojom-shared-internal.h"
#include "services/ui/public/interfaces/window_tree_constants.mojom-shared-internal.h"
#include "skia/public/interfaces/bitmap.mojom-shared-internal.h"
#include "ui/base/mojo/ui_base_types.mojom-shared-internal.h"
#include "ui/display/mojo/display.mojom-shared-internal.h"
#include "ui/events/mojo/event.mojom-shared-internal.h"
#include "ui/events/mojo/event_constants.mojom-shared-internal.h"
#include "ui/gfx/geometry/mojo/geometry.mojom-shared-internal.h"
#include "ui/display/mojo/display.mojom-shared-internal.h"

namespace mojo {
namespace internal {
class ValidationContext;
}
}
namespace ui {
namespace mojom {
namespace internal {
class WmAccelerator_Data;

#pragma pack(push, 1)
class WmAccelerator_Data {
 public:
  static WmAccelerator_Data* New(mojo::internal::Buffer* buf) {
    return new (buf->Allocate(sizeof(WmAccelerator_Data))) WmAccelerator_Data();
  }

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

  mojo::internal::StructHeader header_;
  uint32_t id;
  uint8_t pad0_[4];
  mojo::internal::Pointer<::ui::mojom::internal::EventMatcher_Data> event_matcher;

 private:
  WmAccelerator_Data() : header_({sizeof(*this), 0}) {
  }
  ~WmAccelerator_Data() = delete;
};
static_assert(sizeof(WmAccelerator_Data) == 24,
              "Bad sizeof(WmAccelerator_Data)");
constexpr uint32_t kWindowManager_OnConnect_Name = 0;
class WindowManager_OnConnect_Params_Data {
 public:
  static WindowManager_OnConnect_Params_Data* New(mojo::internal::Buffer* buf) {
    return new (buf->Allocate(sizeof(WindowManager_OnConnect_Params_Data))) WindowManager_OnConnect_Params_Data();
  }

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

  mojo::internal::StructHeader header_;
  uint16_t client_id;
  uint8_t padfinal_[6];

 private:
  WindowManager_OnConnect_Params_Data() : header_({sizeof(*this), 0}) {
  }
  ~WindowManager_OnConnect_Params_Data() = delete;
};
static_assert(sizeof(WindowManager_OnConnect_Params_Data) == 16,
              "Bad sizeof(WindowManager_OnConnect_Params_Data)");
constexpr uint32_t kWindowManager_WmNewDisplayAdded_Name = 1;
class WindowManager_WmNewDisplayAdded_Params_Data {
 public:
  static WindowManager_WmNewDisplayAdded_Params_Data* New(mojo::internal::Buffer* buf) {
    return new (buf->Allocate(sizeof(WindowManager_WmNewDisplayAdded_Params_Data))) WindowManager_WmNewDisplayAdded_Params_Data();
  }

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

  mojo::internal::StructHeader header_;
  mojo::internal::Pointer<::display::mojom::internal::Display_Data> display;
  mojo::internal::Pointer<::ui::mojom::internal::WindowData_Data> root;
  uint8_t parent_drawn : 1;
  uint8_t pad2_[7];
  mojo::internal::Pointer<::cc::mojom::internal::FrameSinkId_Data> frame_sink_id;
  mojo::internal::Pointer<::cc::mojom::internal::LocalSurfaceId_Data> local_surface_id;

 private:
  WindowManager_WmNewDisplayAdded_Params_Data() : header_({sizeof(*this), 0}) {
  }
  ~WindowManager_WmNewDisplayAdded_Params_Data() = delete;
};
static_assert(sizeof(WindowManager_WmNewDisplayAdded_Params_Data) == 48,
              "Bad sizeof(WindowManager_WmNewDisplayAdded_Params_Data)");
constexpr uint32_t kWindowManager_WmDisplayRemoved_Name = 2;
class WindowManager_WmDisplayRemoved_Params_Data {
 public:
  static WindowManager_WmDisplayRemoved_Params_Data* New(mojo::internal::Buffer* buf) {
    return new (buf->Allocate(sizeof(WindowManager_WmDisplayRemoved_Params_Data))) WindowManager_WmDisplayRemoved_Params_Data();
  }

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

  mojo::internal::StructHeader header_;
  int64_t display_id;

 private:
  WindowManager_WmDisplayRemoved_Params_Data() : header_({sizeof(*this), 0}) {
  }
  ~WindowManager_WmDisplayRemoved_Params_Data() = delete;
};
static_assert(sizeof(WindowManager_WmDisplayRemoved_Params_Data) == 16,
              "Bad sizeof(WindowManager_WmDisplayRemoved_Params_Data)");
constexpr uint32_t kWindowManager_WmDisplayModified_Name = 3;
class WindowManager_WmDisplayModified_Params_Data {
 public:
  static WindowManager_WmDisplayModified_Params_Data* New(mojo::internal::Buffer* buf) {
    return new (buf->Allocate(sizeof(WindowManager_WmDisplayModified_Params_Data))) WindowManager_WmDisplayModified_Params_Data();
  }

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

  mojo::internal::StructHeader header_;
  mojo::internal::Pointer<::display::mojom::internal::Display_Data> display;

 private:
  WindowManager_WmDisplayModified_Params_Data() : header_({sizeof(*this), 0}) {
  }
  ~WindowManager_WmDisplayModified_Params_Data() = delete;
};
static_assert(sizeof(WindowManager_WmDisplayModified_Params_Data) == 16,
              "Bad sizeof(WindowManager_WmDisplayModified_Params_Data)");
constexpr uint32_t kWindowManager_WmSetBounds_Name = 4;
class WindowManager_WmSetBounds_Params_Data {
 public:
  static WindowManager_WmSetBounds_Params_Data* New(mojo::internal::Buffer* buf) {
    return new (buf->Allocate(sizeof(WindowManager_WmSetBounds_Params_Data))) WindowManager_WmSetBounds_Params_Data();
  }

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

  mojo::internal::StructHeader header_;
  uint32_t change_id;
  uint32_t window_id;
  mojo::internal::Pointer<::gfx::mojom::internal::Rect_Data> bounds;

 private:
  WindowManager_WmSetBounds_Params_Data() : header_({sizeof(*this), 0}) {
  }
  ~WindowManager_WmSetBounds_Params_Data() = delete;
};
static_assert(sizeof(WindowManager_WmSetBounds_Params_Data) == 24,
              "Bad sizeof(WindowManager_WmSetBounds_Params_Data)");
constexpr uint32_t kWindowManager_WmSetProperty_Name = 5;
class WindowManager_WmSetProperty_Params_Data {
 public:
  static WindowManager_WmSetProperty_Params_Data* New(mojo::internal::Buffer* buf) {
    return new (buf->Allocate(sizeof(WindowManager_WmSetProperty_Params_Data))) WindowManager_WmSetProperty_Params_Data();
  }

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

  mojo::internal::StructHeader header_;
  uint32_t change_id;
  uint32_t window_id;
  mojo::internal::Pointer<mojo::internal::String_Data> name;
  mojo::internal::Pointer<mojo::internal::Array_Data<uint8_t>> value;

 private:
  WindowManager_WmSetProperty_Params_Data() : header_({sizeof(*this), 0}) {
  }
  ~WindowManager_WmSetProperty_Params_Data() = delete;
};
static_assert(sizeof(WindowManager_WmSetProperty_Params_Data) == 32,
              "Bad sizeof(WindowManager_WmSetProperty_Params_Data)");
constexpr uint32_t kWindowManager_WmSetModalType_Name = 6;
class WindowManager_WmSetModalType_Params_Data {
 public:
  static WindowManager_WmSetModalType_Params_Data* New(mojo::internal::Buffer* buf) {
    return new (buf->Allocate(sizeof(WindowManager_WmSetModalType_Params_Data))) WindowManager_WmSetModalType_Params_Data();
  }

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

  mojo::internal::StructHeader header_;
  uint32_t window_id;
  int32_t type;

 private:
  WindowManager_WmSetModalType_Params_Data() : header_({sizeof(*this), 0}) {
  }
  ~WindowManager_WmSetModalType_Params_Data() = delete;
};
static_assert(sizeof(WindowManager_WmSetModalType_Params_Data) == 16,
              "Bad sizeof(WindowManager_WmSetModalType_Params_Data)");
constexpr uint32_t kWindowManager_WmSetCanFocus_Name = 7;
class WindowManager_WmSetCanFocus_Params_Data {
 public:
  static WindowManager_WmSetCanFocus_Params_Data* New(mojo::internal::Buffer* buf) {
    return new (buf->Allocate(sizeof(WindowManager_WmSetCanFocus_Params_Data))) WindowManager_WmSetCanFocus_Params_Data();
  }

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

  mojo::internal::StructHeader header_;
  uint32_t window_id;
  uint8_t can_focus : 1;
  uint8_t padfinal_[3];

 private:
  WindowManager_WmSetCanFocus_Params_Data() : header_({sizeof(*this), 0}) {
  }
  ~WindowManager_WmSetCanFocus_Params_Data() = delete;
};
static_assert(sizeof(WindowManager_WmSetCanFocus_Params_Data) == 16,
              "Bad sizeof(WindowManager_WmSetCanFocus_Params_Data)");
constexpr uint32_t kWindowManager_WmCreateTopLevelWindow_Name = 8;
class WindowManager_WmCreateTopLevelWindow_Params_Data {
 public:
  static WindowManager_WmCreateTopLevelWindow_Params_Data* New(mojo::internal::Buffer* buf) {
    return new (buf->Allocate(sizeof(WindowManager_WmCreateTopLevelWindow_Params_Data))) WindowManager_WmCreateTopLevelWindow_Params_Data();
  }

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

  mojo::internal::StructHeader header_;
  uint32_t change_id;
  uint16_t requesting_client_id;
  uint8_t pad1_[2];
  mojo::internal::Pointer<mojo::internal::Map_Data<mojo::internal::Pointer<mojo::internal::String_Data>, mojo::internal::Pointer<mojo::internal::Array_Data<uint8_t>>>> properties;

 private:
  WindowManager_WmCreateTopLevelWindow_Params_Data() : header_({sizeof(*this), 0}) {
  }
  ~WindowManager_WmCreateTopLevelWindow_Params_Data() = delete;
};
static_assert(sizeof(WindowManager_WmCreateTopLevelWindow_Params_Data) == 24,
              "Bad sizeof(WindowManager_WmCreateTopLevelWindow_Params_Data)");
constexpr uint32_t kWindowManager_WmClientJankinessChanged_Name = 9;
class WindowManager_WmClientJankinessChanged_Params_Data {
 public:
  static WindowManager_WmClientJankinessChanged_Params_Data* New(mojo::internal::Buffer* buf) {
    return new (buf->Allocate(sizeof(WindowManager_WmClientJankinessChanged_Params_Data))) WindowManager_WmClientJankinessChanged_Params_Data();
  }

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

  mojo::internal::StructHeader header_;
  uint16_t client_id;
  uint8_t janky : 1;
  uint8_t padfinal_[5];

 private:
  WindowManager_WmClientJankinessChanged_Params_Data() : header_({sizeof(*this), 0}) {
  }
  ~WindowManager_WmClientJankinessChanged_Params_Data() = delete;
};
static_assert(sizeof(WindowManager_WmClientJankinessChanged_Params_Data) == 16,
              "Bad sizeof(WindowManager_WmClientJankinessChanged_Params_Data)");
constexpr uint32_t kWindowManager_WmBuildDragImage_Name = 10;
class WindowManager_WmBuildDragImage_Params_Data {
 public:
  static WindowManager_WmBuildDragImage_Params_Data* New(mojo::internal::Buffer* buf) {
    return new (buf->Allocate(sizeof(WindowManager_WmBuildDragImage_Params_Data))) WindowManager_WmBuildDragImage_Params_Data();
  }

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

  mojo::internal::StructHeader header_;
  mojo::internal::Pointer<::gfx::mojom::internal::Point_Data> screen_location;
  mojo::internal::Pointer<::skia::mojom::internal::Bitmap_Data> drag_image;
  mojo::internal::Pointer<::gfx::mojom::internal::Vector2d_Data> drag_image_offset;
  int32_t source;
  uint8_t padfinal_[4];

 private:
  WindowManager_WmBuildDragImage_Params_Data() : header_({sizeof(*this), 0}) {
  }
  ~WindowManager_WmBuildDragImage_Params_Data() = delete;
};
static_assert(sizeof(WindowManager_WmBuildDragImage_Params_Data) == 40,
              "Bad sizeof(WindowManager_WmBuildDragImage_Params_Data)");
constexpr uint32_t kWindowManager_WmMoveDragImage_Name = 11;
class WindowManager_WmMoveDragImage_Params_Data {
 public:
  static WindowManager_WmMoveDragImage_Params_Data* New(mojo::internal::Buffer* buf) {
    return new (buf->Allocate(sizeof(WindowManager_WmMoveDragImage_Params_Data))) WindowManager_WmMoveDragImage_Params_Data();
  }

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

  mojo::internal::StructHeader header_;
  mojo::internal::Pointer<::gfx::mojom::internal::Point_Data> screen_location;

 private:
  WindowManager_WmMoveDragImage_Params_Data() : header_({sizeof(*this), 0}) {
  }
  ~WindowManager_WmMoveDragImage_Params_Data() = delete;
};
static_assert(sizeof(WindowManager_WmMoveDragImage_Params_Data) == 16,
              "Bad sizeof(WindowManager_WmMoveDragImage_Params_Data)");
class WindowManager_WmMoveDragImage_ResponseParams_Data {
 public:
  static WindowManager_WmMoveDragImage_ResponseParams_Data* New(mojo::internal::Buffer* buf) {
    return new (buf->Allocate(sizeof(WindowManager_WmMoveDragImage_ResponseParams_Data))) WindowManager_WmMoveDragImage_ResponseParams_Data();
  }

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

  mojo::internal::StructHeader header_;

 private:
  WindowManager_WmMoveDragImage_ResponseParams_Data() : header_({sizeof(*this), 0}) {
  }
  ~WindowManager_WmMoveDragImage_ResponseParams_Data() = delete;
};
static_assert(sizeof(WindowManager_WmMoveDragImage_ResponseParams_Data) == 8,
              "Bad sizeof(WindowManager_WmMoveDragImage_ResponseParams_Data)");
constexpr uint32_t kWindowManager_WmDestroyDragImage_Name = 12;
class WindowManager_WmDestroyDragImage_Params_Data {
 public:
  static WindowManager_WmDestroyDragImage_Params_Data* New(mojo::internal::Buffer* buf) {
    return new (buf->Allocate(sizeof(WindowManager_WmDestroyDragImage_Params_Data))) WindowManager_WmDestroyDragImage_Params_Data();
  }

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

  mojo::internal::StructHeader header_;

 private:
  WindowManager_WmDestroyDragImage_Params_Data() : header_({sizeof(*this), 0}) {
  }
  ~WindowManager_WmDestroyDragImage_Params_Data() = delete;
};
static_assert(sizeof(WindowManager_WmDestroyDragImage_Params_Data) == 8,
              "Bad sizeof(WindowManager_WmDestroyDragImage_Params_Data)");
constexpr uint32_t kWindowManager_WmPerformMoveLoop_Name = 13;
class WindowManager_WmPerformMoveLoop_Params_Data {
 public:
  static WindowManager_WmPerformMoveLoop_Params_Data* New(mojo::internal::Buffer* buf) {
    return new (buf->Allocate(sizeof(WindowManager_WmPerformMoveLoop_Params_Data))) WindowManager_WmPerformMoveLoop_Params_Data();
  }

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

  mojo::internal::StructHeader header_;
  uint32_t change_id;
  uint32_t window_id;
  int32_t source;
  uint8_t pad2_[4];
  mojo::internal::Pointer<::gfx::mojom::internal::Point_Data> cursor_location;

 private:
  WindowManager_WmPerformMoveLoop_Params_Data() : header_({sizeof(*this), 0}) {
  }
  ~WindowManager_WmPerformMoveLoop_Params_Data() = delete;
};
static_assert(sizeof(WindowManager_WmPerformMoveLoop_Params_Data) == 32,
              "Bad sizeof(WindowManager_WmPerformMoveLoop_Params_Data)");
constexpr uint32_t kWindowManager_WmCancelMoveLoop_Name = 14;
class WindowManager_WmCancelMoveLoop_Params_Data {
 public:
  static WindowManager_WmCancelMoveLoop_Params_Data* New(mojo::internal::Buffer* buf) {
    return new (buf->Allocate(sizeof(WindowManager_WmCancelMoveLoop_Params_Data))) WindowManager_WmCancelMoveLoop_Params_Data();
  }

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

  mojo::internal::StructHeader header_;
  uint32_t change_id;
  uint8_t padfinal_[4];

 private:
  WindowManager_WmCancelMoveLoop_Params_Data() : header_({sizeof(*this), 0}) {
  }
  ~WindowManager_WmCancelMoveLoop_Params_Data() = delete;
};
static_assert(sizeof(WindowManager_WmCancelMoveLoop_Params_Data) == 16,
              "Bad sizeof(WindowManager_WmCancelMoveLoop_Params_Data)");
constexpr uint32_t kWindowManager_WmDeactivateWindow_Name = 15;
class WindowManager_WmDeactivateWindow_Params_Data {
 public:
  static WindowManager_WmDeactivateWindow_Params_Data* New(mojo::internal::Buffer* buf) {
    return new (buf->Allocate(sizeof(WindowManager_WmDeactivateWindow_Params_Data))) WindowManager_WmDeactivateWindow_Params_Data();
  }

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

  mojo::internal::StructHeader header_;
  uint32_t window_id;
  uint8_t padfinal_[4];

 private:
  WindowManager_WmDeactivateWindow_Params_Data() : header_({sizeof(*this), 0}) {
  }
  ~WindowManager_WmDeactivateWindow_Params_Data() = delete;
};
static_assert(sizeof(WindowManager_WmDeactivateWindow_Params_Data) == 16,
              "Bad sizeof(WindowManager_WmDeactivateWindow_Params_Data)");
constexpr uint32_t kWindowManager_WmStackAbove_Name = 16;
class WindowManager_WmStackAbove_Params_Data {
 public:
  static WindowManager_WmStackAbove_Params_Data* New(mojo::internal::Buffer* buf) {
    return new (buf->Allocate(sizeof(WindowManager_WmStackAbove_Params_Data))) WindowManager_WmStackAbove_Params_Data();
  }

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

  mojo::internal::StructHeader header_;
  uint32_t change_id;
  uint32_t above_id;
  uint32_t below_id;
  uint8_t padfinal_[4];

 private:
  WindowManager_WmStackAbove_Params_Data() : header_({sizeof(*this), 0}) {
  }
  ~WindowManager_WmStackAbove_Params_Data() = delete;
};
static_assert(sizeof(WindowManager_WmStackAbove_Params_Data) == 24,
              "Bad sizeof(WindowManager_WmStackAbove_Params_Data)");
constexpr uint32_t kWindowManager_WmStackAtTop_Name = 17;
class WindowManager_WmStackAtTop_Params_Data {
 public:
  static WindowManager_WmStackAtTop_Params_Data* New(mojo::internal::Buffer* buf) {
    return new (buf->Allocate(sizeof(WindowManager_WmStackAtTop_Params_Data))) WindowManager_WmStackAtTop_Params_Data();
  }

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

  mojo::internal::StructHeader header_;
  uint32_t change_id;
  uint32_t window_id;

 private:
  WindowManager_WmStackAtTop_Params_Data() : header_({sizeof(*this), 0}) {
  }
  ~WindowManager_WmStackAtTop_Params_Data() = delete;
};
static_assert(sizeof(WindowManager_WmStackAtTop_Params_Data) == 16,
              "Bad sizeof(WindowManager_WmStackAtTop_Params_Data)");
constexpr uint32_t kWindowManager_OnAccelerator_Name = 18;
class WindowManager_OnAccelerator_Params_Data {
 public:
  static WindowManager_OnAccelerator_Params_Data* New(mojo::internal::Buffer* buf) {
    return new (buf->Allocate(sizeof(WindowManager_OnAccelerator_Params_Data))) WindowManager_OnAccelerator_Params_Data();
  }

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

  mojo::internal::StructHeader header_;
  uint32_t ack_id;
  uint32_t accelerator_id;
  mojo::internal::Pointer<::ui::mojom::internal::Event_Data> event;

 private:
  WindowManager_OnAccelerator_Params_Data() : header_({sizeof(*this), 0}) {
  }
  ~WindowManager_OnAccelerator_Params_Data() = delete;
};
static_assert(sizeof(WindowManager_OnAccelerator_Params_Data) == 24,
              "Bad sizeof(WindowManager_OnAccelerator_Params_Data)");
constexpr uint32_t kWindowManagerClient_AddActivationParent_Name = 0;
class WindowManagerClient_AddActivationParent_Params_Data {
 public:
  static WindowManagerClient_AddActivationParent_Params_Data* New(mojo::internal::Buffer* buf) {
    return new (buf->Allocate(sizeof(WindowManagerClient_AddActivationParent_Params_Data))) WindowManagerClient_AddActivationParent_Params_Data();
  }

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

  mojo::internal::StructHeader header_;
  uint32_t window_id;
  uint8_t padfinal_[4];

 private:
  WindowManagerClient_AddActivationParent_Params_Data() : header_({sizeof(*this), 0}) {
  }
  ~WindowManagerClient_AddActivationParent_Params_Data() = delete;
};
static_assert(sizeof(WindowManagerClient_AddActivationParent_Params_Data) == 16,
              "Bad sizeof(WindowManagerClient_AddActivationParent_Params_Data)");
constexpr uint32_t kWindowManagerClient_RemoveActivationParent_Name = 1;
class WindowManagerClient_RemoveActivationParent_Params_Data {
 public:
  static WindowManagerClient_RemoveActivationParent_Params_Data* New(mojo::internal::Buffer* buf) {
    return new (buf->Allocate(sizeof(WindowManagerClient_RemoveActivationParent_Params_Data))) WindowManagerClient_RemoveActivationParent_Params_Data();
  }

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

  mojo::internal::StructHeader header_;
  uint32_t window_id;
  uint8_t padfinal_[4];

 private:
  WindowManagerClient_RemoveActivationParent_Params_Data() : header_({sizeof(*this), 0}) {
  }
  ~WindowManagerClient_RemoveActivationParent_Params_Data() = delete;
};
static_assert(sizeof(WindowManagerClient_RemoveActivationParent_Params_Data) == 16,
              "Bad sizeof(WindowManagerClient_RemoveActivationParent_Params_Data)");
constexpr uint32_t kWindowManagerClient_ActivateNextWindow_Name = 2;
class WindowManagerClient_ActivateNextWindow_Params_Data {
 public:
  static WindowManagerClient_ActivateNextWindow_Params_Data* New(mojo::internal::Buffer* buf) {
    return new (buf->Allocate(sizeof(WindowManagerClient_ActivateNextWindow_Params_Data))) WindowManagerClient_ActivateNextWindow_Params_Data();
  }

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

  mojo::internal::StructHeader header_;

 private:
  WindowManagerClient_ActivateNextWindow_Params_Data() : header_({sizeof(*this), 0}) {
  }
  ~WindowManagerClient_ActivateNextWindow_Params_Data() = delete;
};
static_assert(sizeof(WindowManagerClient_ActivateNextWindow_Params_Data) == 8,
              "Bad sizeof(WindowManagerClient_ActivateNextWindow_Params_Data)");
constexpr uint32_t kWindowManagerClient_SetExtendedHitArea_Name = 3;
class WindowManagerClient_SetExtendedHitArea_Params_Data {
 public:
  static WindowManagerClient_SetExtendedHitArea_Params_Data* New(mojo::internal::Buffer* buf) {
    return new (buf->Allocate(sizeof(WindowManagerClient_SetExtendedHitArea_Params_Data))) WindowManagerClient_SetExtendedHitArea_Params_Data();
  }

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

  mojo::internal::StructHeader header_;
  uint32_t window_id;
  uint8_t pad0_[4];
  mojo::internal::Pointer<::gfx::mojom::internal::Insets_Data> hit_area;

 private:
  WindowManagerClient_SetExtendedHitArea_Params_Data() : header_({sizeof(*this), 0}) {
  }
  ~WindowManagerClient_SetExtendedHitArea_Params_Data() = delete;
};
static_assert(sizeof(WindowManagerClient_SetExtendedHitArea_Params_Data) == 24,
              "Bad sizeof(WindowManagerClient_SetExtendedHitArea_Params_Data)");
constexpr uint32_t kWindowManagerClient_AddAccelerators_Name = 4;
class WindowManagerClient_AddAccelerators_Params_Data {
 public:
  static WindowManagerClient_AddAccelerators_Params_Data* New(mojo::internal::Buffer* buf) {
    return new (buf->Allocate(sizeof(WindowManagerClient_AddAccelerators_Params_Data))) WindowManagerClient_AddAccelerators_Params_Data();
  }

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

  mojo::internal::StructHeader header_;
  mojo::internal::Pointer<mojo::internal::Array_Data<mojo::internal::Pointer<internal::WmAccelerator_Data>>> accelerators;

 private:
  WindowManagerClient_AddAccelerators_Params_Data() : header_({sizeof(*this), 0}) {
  }
  ~WindowManagerClient_AddAccelerators_Params_Data() = delete;
};
static_assert(sizeof(WindowManagerClient_AddAccelerators_Params_Data) == 16,
              "Bad sizeof(WindowManagerClient_AddAccelerators_Params_Data)");
class WindowManagerClient_AddAccelerators_ResponseParams_Data {
 public:
  static WindowManagerClient_AddAccelerators_ResponseParams_Data* New(mojo::internal::Buffer* buf) {
    return new (buf->Allocate(sizeof(WindowManagerClient_AddAccelerators_ResponseParams_Data))) WindowManagerClient_AddAccelerators_ResponseParams_Data();
  }

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

  mojo::internal::StructHeader header_;
  uint8_t success : 1;
  uint8_t padfinal_[7];

 private:
  WindowManagerClient_AddAccelerators_ResponseParams_Data() : header_({sizeof(*this), 0}) {
  }
  ~WindowManagerClient_AddAccelerators_ResponseParams_Data() = delete;
};
static_assert(sizeof(WindowManagerClient_AddAccelerators_ResponseParams_Data) == 16,
              "Bad sizeof(WindowManagerClient_AddAccelerators_ResponseParams_Data)");
constexpr uint32_t kWindowManagerClient_RemoveAccelerator_Name = 5;
class WindowManagerClient_RemoveAccelerator_Params_Data {
 public:
  static WindowManagerClient_RemoveAccelerator_Params_Data* New(mojo::internal::Buffer* buf) {
    return new (buf->Allocate(sizeof(WindowManagerClient_RemoveAccelerator_Params_Data))) WindowManagerClient_RemoveAccelerator_Params_Data();
  }

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

  mojo::internal::StructHeader header_;
  uint32_t id;
  uint8_t padfinal_[4];

 private:
  WindowManagerClient_RemoveAccelerator_Params_Data() : header_({sizeof(*this), 0}) {
  }
  ~WindowManagerClient_RemoveAccelerator_Params_Data() = delete;
};
static_assert(sizeof(WindowManagerClient_RemoveAccelerator_Params_Data) == 16,
              "Bad sizeof(WindowManagerClient_RemoveAccelerator_Params_Data)");
constexpr uint32_t kWindowManagerClient_SetDisplayRoot_Name = 6;
class WindowManagerClient_SetDisplayRoot_Params_Data {
 public:
  static WindowManagerClient_SetDisplayRoot_Params_Data* New(mojo::internal::Buffer* buf) {
    return new (buf->Allocate(sizeof(WindowManagerClient_SetDisplayRoot_Params_Data))) WindowManagerClient_SetDisplayRoot_Params_Data();
  }

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

  mojo::internal::StructHeader header_;
  mojo::internal::Pointer<::display::mojom::internal::Display_Data> display;
  mojo::internal::Pointer<::ui::mojom::internal::WmViewportMetrics_Data> viewport_metrics;
  uint8_t is_primary_display : 1;
  uint8_t pad2_[3];
  uint32_t window_id;

 private:
  WindowManagerClient_SetDisplayRoot_Params_Data() : header_({sizeof(*this), 0}) {
  }
  ~WindowManagerClient_SetDisplayRoot_Params_Data() = delete;
};
static_assert(sizeof(WindowManagerClient_SetDisplayRoot_Params_Data) == 32,
              "Bad sizeof(WindowManagerClient_SetDisplayRoot_Params_Data)");
class WindowManagerClient_SetDisplayRoot_ResponseParams_Data {
 public:
  static WindowManagerClient_SetDisplayRoot_ResponseParams_Data* New(mojo::internal::Buffer* buf) {
    return new (buf->Allocate(sizeof(WindowManagerClient_SetDisplayRoot_ResponseParams_Data))) WindowManagerClient_SetDisplayRoot_ResponseParams_Data();
  }

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

  mojo::internal::StructHeader header_;
  mojo::internal::Pointer<::cc::mojom::internal::FrameSinkId_Data> frame_sink_id;

 private:
  WindowManagerClient_SetDisplayRoot_ResponseParams_Data() : header_({sizeof(*this), 0}) {
  }
  ~WindowManagerClient_SetDisplayRoot_ResponseParams_Data() = delete;
};
static_assert(sizeof(WindowManagerClient_SetDisplayRoot_ResponseParams_Data) == 16,
              "Bad sizeof(WindowManagerClient_SetDisplayRoot_ResponseParams_Data)");
constexpr uint32_t kWindowManagerClient_WmResponse_Name = 7;
class WindowManagerClient_WmResponse_Params_Data {
 public:
  static WindowManagerClient_WmResponse_Params_Data* New(mojo::internal::Buffer* buf) {
    return new (buf->Allocate(sizeof(WindowManagerClient_WmResponse_Params_Data))) WindowManagerClient_WmResponse_Params_Data();
  }

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

  mojo::internal::StructHeader header_;
  uint32_t change_id;
  uint8_t response : 1;
  uint8_t padfinal_[3];

 private:
  WindowManagerClient_WmResponse_Params_Data() : header_({sizeof(*this), 0}) {
  }
  ~WindowManagerClient_WmResponse_Params_Data() = delete;
};
static_assert(sizeof(WindowManagerClient_WmResponse_Params_Data) == 16,
              "Bad sizeof(WindowManagerClient_WmResponse_Params_Data)");
constexpr uint32_t kWindowManagerClient_WmSetBoundsResponse_Name = 8;
class WindowManagerClient_WmSetBoundsResponse_Params_Data {
 public:
  static WindowManagerClient_WmSetBoundsResponse_Params_Data* New(mojo::internal::Buffer* buf) {
    return new (buf->Allocate(sizeof(WindowManagerClient_WmSetBoundsResponse_Params_Data))) WindowManagerClient_WmSetBoundsResponse_Params_Data();
  }

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

  mojo::internal::StructHeader header_;
  uint32_t change_id;
  uint8_t padfinal_[4];

 private:
  WindowManagerClient_WmSetBoundsResponse_Params_Data() : header_({sizeof(*this), 0}) {
  }
  ~WindowManagerClient_WmSetBoundsResponse_Params_Data() = delete;
};
static_assert(sizeof(WindowManagerClient_WmSetBoundsResponse_Params_Data) == 16,
              "Bad sizeof(WindowManagerClient_WmSetBoundsResponse_Params_Data)");
constexpr uint32_t kWindowManagerClient_WmRequestClose_Name = 9;
class WindowManagerClient_WmRequestClose_Params_Data {
 public:
  static WindowManagerClient_WmRequestClose_Params_Data* New(mojo::internal::Buffer* buf) {
    return new (buf->Allocate(sizeof(WindowManagerClient_WmRequestClose_Params_Data))) WindowManagerClient_WmRequestClose_Params_Data();
  }

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

  mojo::internal::StructHeader header_;
  uint32_t window_id;
  uint8_t padfinal_[4];

 private:
  WindowManagerClient_WmRequestClose_Params_Data() : header_({sizeof(*this), 0}) {
  }
  ~WindowManagerClient_WmRequestClose_Params_Data() = delete;
};
static_assert(sizeof(WindowManagerClient_WmRequestClose_Params_Data) == 16,
              "Bad sizeof(WindowManagerClient_WmRequestClose_Params_Data)");
constexpr uint32_t kWindowManagerClient_WmSetFrameDecorationValues_Name = 10;
class WindowManagerClient_WmSetFrameDecorationValues_Params_Data {
 public:
  static WindowManagerClient_WmSetFrameDecorationValues_Params_Data* New(mojo::internal::Buffer* buf) {
    return new (buf->Allocate(sizeof(WindowManagerClient_WmSetFrameDecorationValues_Params_Data))) WindowManagerClient_WmSetFrameDecorationValues_Params_Data();
  }

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

  mojo::internal::StructHeader header_;
  mojo::internal::Pointer<::ui::mojom::internal::FrameDecorationValues_Data> values;

 private:
  WindowManagerClient_WmSetFrameDecorationValues_Params_Data() : header_({sizeof(*this), 0}) {
  }
  ~WindowManagerClient_WmSetFrameDecorationValues_Params_Data() = delete;
};
static_assert(sizeof(WindowManagerClient_WmSetFrameDecorationValues_Params_Data) == 16,
              "Bad sizeof(WindowManagerClient_WmSetFrameDecorationValues_Params_Data)");
constexpr uint32_t kWindowManagerClient_WmSetNonClientCursor_Name = 11;
class WindowManagerClient_WmSetNonClientCursor_Params_Data {
 public:
  static WindowManagerClient_WmSetNonClientCursor_Params_Data* New(mojo::internal::Buffer* buf) {
    return new (buf->Allocate(sizeof(WindowManagerClient_WmSetNonClientCursor_Params_Data))) WindowManagerClient_WmSetNonClientCursor_Params_Data();
  }

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

  mojo::internal::StructHeader header_;
  uint32_t window_id;
  uint8_t pad0_[4];
  mojo::internal::Pointer<::ui::mojom::internal::CursorData_Data> cursor;

 private:
  WindowManagerClient_WmSetNonClientCursor_Params_Data() : header_({sizeof(*this), 0}) {
  }
  ~WindowManagerClient_WmSetNonClientCursor_Params_Data() = delete;
};
static_assert(sizeof(WindowManagerClient_WmSetNonClientCursor_Params_Data) == 24,
              "Bad sizeof(WindowManagerClient_WmSetNonClientCursor_Params_Data)");
constexpr uint32_t kWindowManagerClient_OnWmCreatedTopLevelWindow_Name = 12;
class WindowManagerClient_OnWmCreatedTopLevelWindow_Params_Data {
 public:
  static WindowManagerClient_OnWmCreatedTopLevelWindow_Params_Data* New(mojo::internal::Buffer* buf) {
    return new (buf->Allocate(sizeof(WindowManagerClient_OnWmCreatedTopLevelWindow_Params_Data))) WindowManagerClient_OnWmCreatedTopLevelWindow_Params_Data();
  }

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

  mojo::internal::StructHeader header_;
  uint32_t change_id;
  uint32_t window_id;

 private:
  WindowManagerClient_OnWmCreatedTopLevelWindow_Params_Data() : header_({sizeof(*this), 0}) {
  }
  ~WindowManagerClient_OnWmCreatedTopLevelWindow_Params_Data() = delete;
};
static_assert(sizeof(WindowManagerClient_OnWmCreatedTopLevelWindow_Params_Data) == 16,
              "Bad sizeof(WindowManagerClient_OnWmCreatedTopLevelWindow_Params_Data)");
constexpr uint32_t kWindowManagerClient_OnAcceleratorAck_Name = 13;
class WindowManagerClient_OnAcceleratorAck_Params_Data {
 public:
  static WindowManagerClient_OnAcceleratorAck_Params_Data* New(mojo::internal::Buffer* buf) {
    return new (buf->Allocate(sizeof(WindowManagerClient_OnAcceleratorAck_Params_Data))) WindowManagerClient_OnAcceleratorAck_Params_Data();
  }

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

  mojo::internal::StructHeader header_;
  uint32_t ack_id;
  int32_t event_result;
  mojo::internal::Pointer<mojo::internal::Map_Data<mojo::internal::Pointer<mojo::internal::String_Data>, mojo::internal::Pointer<mojo::internal::Array_Data<uint8_t>>>> properties;

 private:
  WindowManagerClient_OnAcceleratorAck_Params_Data() : header_({sizeof(*this), 0}) {
  }
  ~WindowManagerClient_OnAcceleratorAck_Params_Data() = delete;
};
static_assert(sizeof(WindowManagerClient_OnAcceleratorAck_Params_Data) == 24,
              "Bad sizeof(WindowManagerClient_OnAcceleratorAck_Params_Data)");

#pragma pack(pop)

}  // namespace internal
}  // namespace mojom
}  // namespace ui

#endif  // SERVICES_UI_PUBLIC_INTERFACES_WINDOW_MANAGER_MOJOM_SHARED_INTERNAL_H_