Debug/gen/services/ui/public/interfaces/window_tree.mojom-blink.cc

// Copyright 2013 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#if defined(__clang__)
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wunused-private-field"
#elif defined(_MSC_VER)
#pragma warning(push)
#pragma warning(disable:4056)
#pragma warning(disable:4065)
#pragma warning(disable:4756)
#endif

#include "services/ui/public/interfaces/window_tree.mojom-blink.h"

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

#include "base/logging.h"
#include "base/trace_event/trace_event.h"
#include "mojo/public/cpp/bindings/lib/message_builder.h"
#include "mojo/public/cpp/bindings/lib/serialization_util.h"
#include "mojo/public/cpp/bindings/lib/validate_params.h"
#include "mojo/public/cpp/bindings/lib/validation_context.h"
#include "mojo/public/cpp/bindings/lib/validation_errors.h"
#include "mojo/public/interfaces/bindings/interface_control_messages.mojom.h"
#include "mojo/public/cpp/bindings/lib/wtf_serialization.h"
#include "cc/ipc/frame_sink_id_struct_traits.h"
#include "cc/ipc/local_surface_id_struct_traits.h"
#include "cc/ipc/surface_id_struct_traits.h"
#include "cc/ipc/surface_info_struct_traits.h"
#include "third_party/WebKit/Source/platform/mojo/GeometryStructTraits.h"
#include "ui/gfx/geometry/mojo/geometry_struct_traits.h"
namespace ui {
namespace mojom {
namespace blink {
const char WindowTree::Name_[] = "ui::mojom::WindowTree";

class WindowTree_GetWindowTree_ForwardToCallback
    : public mojo::MessageReceiver {
 public:
  WindowTree_GetWindowTree_ForwardToCallback(
      const WindowTree::GetWindowTreeCallback& callback
      ) : callback_(std::move(callback)) {
  }
  bool Accept(mojo::Message* message) override;
 private:
  WindowTree::GetWindowTreeCallback callback_;
  DISALLOW_COPY_AND_ASSIGN(WindowTree_GetWindowTree_ForwardToCallback);
};
bool WindowTree_GetWindowTree_ForwardToCallback::Accept(
    mojo::Message* message) {
  internal::WindowTree_GetWindowTree_ResponseParams_Data* params =
      reinterpret_cast<internal::WindowTree_GetWindowTree_ResponseParams_Data*>(
          message->mutable_payload());
  
  mojo::internal::SerializationContext serialization_context;
  serialization_context.handles.Swap((message)->mutable_handles());
  serialization_context.associated_endpoint_handles.swap(
      *(message)->mutable_associated_endpoint_handles());
  bool success = true;
  WTF::Vector<::ui::mojom::blink::WindowDataPtr> p_windows{};
  WindowTree_GetWindowTree_ResponseParamsDataView input_data_view(params, &serialization_context);
  
  if (!input_data_view.ReadWindows(&p_windows))
    success = false;
  if (!success) {
    ReportValidationErrorForMessage(
        message,
        mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
        "WindowTree::GetWindowTree response deserializer");
    return false;
  }
  if (!callback_.is_null()) {
    mojo::internal::MessageDispatchContext context(message);
    std::move(callback_).Run(
std::move(p_windows));
  }
  return true;
}

class WindowTree_Embed_ForwardToCallback
    : public mojo::MessageReceiver {
 public:
  WindowTree_Embed_ForwardToCallback(
      const WindowTree::EmbedCallback& callback
      ) : callback_(std::move(callback)) {
  }
  bool Accept(mojo::Message* message) override;
 private:
  WindowTree::EmbedCallback callback_;
  DISALLOW_COPY_AND_ASSIGN(WindowTree_Embed_ForwardToCallback);
};
bool WindowTree_Embed_ForwardToCallback::Accept(
    mojo::Message* message) {
  internal::WindowTree_Embed_ResponseParams_Data* params =
      reinterpret_cast<internal::WindowTree_Embed_ResponseParams_Data*>(
          message->mutable_payload());
  
  mojo::internal::SerializationContext serialization_context;
  serialization_context.handles.Swap((message)->mutable_handles());
  serialization_context.associated_endpoint_handles.swap(
      *(message)->mutable_associated_endpoint_handles());
  bool success = true;
  bool p_success{};
  WindowTree_Embed_ResponseParamsDataView input_data_view(params, &serialization_context);
  
  p_success = input_data_view.success();
  if (!success) {
    ReportValidationErrorForMessage(
        message,
        mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
        "WindowTree::Embed response deserializer");
    return false;
  }
  if (!callback_.is_null()) {
    mojo::internal::MessageDispatchContext context(message);
    std::move(callback_).Run(
std::move(p_success));
  }
  return true;
}

class WindowTree_GetCursorLocationMemory_ForwardToCallback
    : public mojo::MessageReceiver {
 public:
  WindowTree_GetCursorLocationMemory_ForwardToCallback(
      const WindowTree::GetCursorLocationMemoryCallback& callback
      ) : callback_(std::move(callback)) {
  }
  bool Accept(mojo::Message* message) override;
 private:
  WindowTree::GetCursorLocationMemoryCallback callback_;
  DISALLOW_COPY_AND_ASSIGN(WindowTree_GetCursorLocationMemory_ForwardToCallback);
};
bool WindowTree_GetCursorLocationMemory_ForwardToCallback::Accept(
    mojo::Message* message) {
  internal::WindowTree_GetCursorLocationMemory_ResponseParams_Data* params =
      reinterpret_cast<internal::WindowTree_GetCursorLocationMemory_ResponseParams_Data*>(
          message->mutable_payload());
  
  mojo::internal::SerializationContext serialization_context;
  serialization_context.handles.Swap((message)->mutable_handles());
  serialization_context.associated_endpoint_handles.swap(
      *(message)->mutable_associated_endpoint_handles());
  bool success = true;
  mojo::ScopedSharedBufferHandle p_cursor_buffer{};
  WindowTree_GetCursorLocationMemory_ResponseParamsDataView input_data_view(params, &serialization_context);
  
  p_cursor_buffer = input_data_view.TakeCursorBuffer();
  if (!success) {
    ReportValidationErrorForMessage(
        message,
        mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
        "WindowTree::GetCursorLocationMemory response deserializer");
    return false;
  }
  if (!callback_.is_null()) {
    mojo::internal::MessageDispatchContext context(message);
    std::move(callback_).Run(
std::move(p_cursor_buffer));
  }
  return true;
}

WindowTreeProxy::WindowTreeProxy(mojo::MessageReceiverWithResponder* receiver)
    : receiver_(receiver) {
}

void WindowTreeProxy::NewWindow(
    uint32_t in_change_id, uint32_t in_window_id, const WTF::Optional<WTF::HashMap<WTF::String, WTF::Vector<uint8_t>>>& in_properties) {
  mojo::internal::SerializationContext serialization_context;
  size_t size = sizeof(::ui::mojom::internal::WindowTree_NewWindow_Params_Data);
  size += mojo::internal::PrepareToSerialize<mojo::MapDataView<mojo::StringDataView, mojo::ArrayDataView<uint8_t>>>(
      in_properties, &serialization_context);
  constexpr uint32_t kFlags = 0;
  mojo::internal::MessageBuilder builder(
      internal::kWindowTree_NewWindow_Name, kFlags, size,
      serialization_context.associated_endpoint_count);

  auto params =
      ::ui::mojom::internal::WindowTree_NewWindow_Params_Data::New(builder.buffer());
  ALLOW_UNUSED_LOCAL(params);
  params->change_id = in_change_id;
  params->window_id = in_window_id;
  typename decltype(params->properties)::BaseType* properties_ptr;
  const mojo::internal::ContainerValidateParams properties_validate_params(
      new mojo::internal::ContainerValidateParams(0, false, new mojo::internal::ContainerValidateParams(0, false, nullptr)), new mojo::internal::ContainerValidateParams(0, false, new mojo::internal::ContainerValidateParams(0, false, nullptr)));
  mojo::internal::Serialize<mojo::MapDataView<mojo::StringDataView, mojo::ArrayDataView<uint8_t>>>(
      in_properties, builder.buffer(), &properties_ptr, &properties_validate_params,
      &serialization_context);
  params->properties.Set(properties_ptr);
  (&serialization_context)->handles.Swap(
      builder.message()->mutable_handles());
  (&serialization_context)->associated_endpoint_handles.swap(
      *builder.message()->mutable_associated_endpoint_handles());
  // This return value may be ignored as false implies the Connector has
  // encountered an error, which will be visible through other means.
  ignore_result(receiver_->Accept(builder.message()));
}

void WindowTreeProxy::NewTopLevelWindow(
    uint32_t in_change_id, uint32_t in_window_id, const WTF::HashMap<WTF::String, WTF::Vector<uint8_t>>& in_properties) {
  mojo::internal::SerializationContext serialization_context;
  size_t size = sizeof(::ui::mojom::internal::WindowTree_NewTopLevelWindow_Params_Data);
  size += mojo::internal::PrepareToSerialize<mojo::MapDataView<mojo::StringDataView, mojo::ArrayDataView<uint8_t>>>(
      in_properties, &serialization_context);
  constexpr uint32_t kFlags = 0;
  mojo::internal::MessageBuilder builder(
      internal::kWindowTree_NewTopLevelWindow_Name, kFlags, size,
      serialization_context.associated_endpoint_count);

  auto params =
      ::ui::mojom::internal::WindowTree_NewTopLevelWindow_Params_Data::New(builder.buffer());
  ALLOW_UNUSED_LOCAL(params);
  params->change_id = in_change_id;
  params->window_id = in_window_id;
  typename decltype(params->properties)::BaseType* properties_ptr;
  const mojo::internal::ContainerValidateParams properties_validate_params(
      new mojo::internal::ContainerValidateParams(0, false, new mojo::internal::ContainerValidateParams(0, false, nullptr)), new mojo::internal::ContainerValidateParams(0, false, new mojo::internal::ContainerValidateParams(0, false, nullptr)));
  mojo::internal::Serialize<mojo::MapDataView<mojo::StringDataView, mojo::ArrayDataView<uint8_t>>>(
      in_properties, builder.buffer(), &properties_ptr, &properties_validate_params,
      &serialization_context);
  params->properties.Set(properties_ptr);
  MOJO_INTERNAL_DLOG_SERIALIZATION_WARNING(
      params->properties.is_null(),
      mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
      "null properties in WindowTree.NewTopLevelWindow request");
  (&serialization_context)->handles.Swap(
      builder.message()->mutable_handles());
  (&serialization_context)->associated_endpoint_handles.swap(
      *builder.message()->mutable_associated_endpoint_handles());
  // This return value may be ignored as false implies the Connector has
  // encountered an error, which will be visible through other means.
  ignore_result(receiver_->Accept(builder.message()));
}

void WindowTreeProxy::DeleteWindow(
    uint32_t in_change_id, uint32_t in_window_id) {
  mojo::internal::SerializationContext serialization_context;
  size_t size = sizeof(::ui::mojom::internal::WindowTree_DeleteWindow_Params_Data);
  constexpr uint32_t kFlags = 0;
  mojo::internal::MessageBuilder builder(
      internal::kWindowTree_DeleteWindow_Name, kFlags, size,
      serialization_context.associated_endpoint_count);

  auto params =
      ::ui::mojom::internal::WindowTree_DeleteWindow_Params_Data::New(builder.buffer());
  ALLOW_UNUSED_LOCAL(params);
  params->change_id = in_change_id;
  params->window_id = in_window_id;
  (&serialization_context)->handles.Swap(
      builder.message()->mutable_handles());
  (&serialization_context)->associated_endpoint_handles.swap(
      *builder.message()->mutable_associated_endpoint_handles());
  // This return value may be ignored as false implies the Connector has
  // encountered an error, which will be visible through other means.
  ignore_result(receiver_->Accept(builder.message()));
}

void WindowTreeProxy::SetCapture(
    uint32_t in_change_id, uint32_t in_window_id) {
  mojo::internal::SerializationContext serialization_context;
  size_t size = sizeof(::ui::mojom::internal::WindowTree_SetCapture_Params_Data);
  constexpr uint32_t kFlags = 0;
  mojo::internal::MessageBuilder builder(
      internal::kWindowTree_SetCapture_Name, kFlags, size,
      serialization_context.associated_endpoint_count);

  auto params =
      ::ui::mojom::internal::WindowTree_SetCapture_Params_Data::New(builder.buffer());
  ALLOW_UNUSED_LOCAL(params);
  params->change_id = in_change_id;
  params->window_id = in_window_id;
  (&serialization_context)->handles.Swap(
      builder.message()->mutable_handles());
  (&serialization_context)->associated_endpoint_handles.swap(
      *builder.message()->mutable_associated_endpoint_handles());
  // This return value may be ignored as false implies the Connector has
  // encountered an error, which will be visible through other means.
  ignore_result(receiver_->Accept(builder.message()));
}

void WindowTreeProxy::ReleaseCapture(
    uint32_t in_change_id, uint32_t in_window_id) {
  mojo::internal::SerializationContext serialization_context;
  size_t size = sizeof(::ui::mojom::internal::WindowTree_ReleaseCapture_Params_Data);
  constexpr uint32_t kFlags = 0;
  mojo::internal::MessageBuilder builder(
      internal::kWindowTree_ReleaseCapture_Name, kFlags, size,
      serialization_context.associated_endpoint_count);

  auto params =
      ::ui::mojom::internal::WindowTree_ReleaseCapture_Params_Data::New(builder.buffer());
  ALLOW_UNUSED_LOCAL(params);
  params->change_id = in_change_id;
  params->window_id = in_window_id;
  (&serialization_context)->handles.Swap(
      builder.message()->mutable_handles());
  (&serialization_context)->associated_endpoint_handles.swap(
      *builder.message()->mutable_associated_endpoint_handles());
  // This return value may be ignored as false implies the Connector has
  // encountered an error, which will be visible through other means.
  ignore_result(receiver_->Accept(builder.message()));
}

void WindowTreeProxy::StartPointerWatcher(
    bool in_want_moves) {
  mojo::internal::SerializationContext serialization_context;
  size_t size = sizeof(::ui::mojom::internal::WindowTree_StartPointerWatcher_Params_Data);
  constexpr uint32_t kFlags = 0;
  mojo::internal::MessageBuilder builder(
      internal::kWindowTree_StartPointerWatcher_Name, kFlags, size,
      serialization_context.associated_endpoint_count);

  auto params =
      ::ui::mojom::internal::WindowTree_StartPointerWatcher_Params_Data::New(builder.buffer());
  ALLOW_UNUSED_LOCAL(params);
  params->want_moves = in_want_moves;
  (&serialization_context)->handles.Swap(
      builder.message()->mutable_handles());
  (&serialization_context)->associated_endpoint_handles.swap(
      *builder.message()->mutable_associated_endpoint_handles());
  // This return value may be ignored as false implies the Connector has
  // encountered an error, which will be visible through other means.
  ignore_result(receiver_->Accept(builder.message()));
}

void WindowTreeProxy::StopPointerWatcher(
    ) {
  mojo::internal::SerializationContext serialization_context;
  size_t size = sizeof(::ui::mojom::internal::WindowTree_StopPointerWatcher_Params_Data);
  constexpr uint32_t kFlags = 0;
  mojo::internal::MessageBuilder builder(
      internal::kWindowTree_StopPointerWatcher_Name, kFlags, size,
      serialization_context.associated_endpoint_count);

  auto params =
      ::ui::mojom::internal::WindowTree_StopPointerWatcher_Params_Data::New(builder.buffer());
  ALLOW_UNUSED_LOCAL(params);
  (&serialization_context)->handles.Swap(
      builder.message()->mutable_handles());
  (&serialization_context)->associated_endpoint_handles.swap(
      *builder.message()->mutable_associated_endpoint_handles());
  // This return value may be ignored as false implies the Connector has
  // encountered an error, which will be visible through other means.
  ignore_result(receiver_->Accept(builder.message()));
}

void WindowTreeProxy::SetWindowBounds(
    uint32_t in_change_id, uint32_t in_window_id, ::gfx::mojom::blink::RectPtr in_bounds, const WTF::Optional<cc::LocalSurfaceId>& in_local_surface_id) {
  mojo::internal::SerializationContext serialization_context;
  size_t size = sizeof(::ui::mojom::internal::WindowTree_SetWindowBounds_Params_Data);
  size += mojo::internal::PrepareToSerialize<::gfx::mojom::RectDataView>(
      in_bounds, &serialization_context);
  size += mojo::internal::PrepareToSerialize<::cc::mojom::LocalSurfaceIdDataView>(
      in_local_surface_id, &serialization_context);
  constexpr uint32_t kFlags = 0;
  mojo::internal::MessageBuilder builder(
      internal::kWindowTree_SetWindowBounds_Name, kFlags, size,
      serialization_context.associated_endpoint_count);

  auto params =
      ::ui::mojom::internal::WindowTree_SetWindowBounds_Params_Data::New(builder.buffer());
  ALLOW_UNUSED_LOCAL(params);
  params->change_id = in_change_id;
  params->window_id = in_window_id;
  typename decltype(params->bounds)::BaseType* bounds_ptr;
  mojo::internal::Serialize<::gfx::mojom::RectDataView>(
      in_bounds, builder.buffer(), &bounds_ptr, &serialization_context);
  params->bounds.Set(bounds_ptr);
  MOJO_INTERNAL_DLOG_SERIALIZATION_WARNING(
      params->bounds.is_null(),
      mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
      "null bounds in WindowTree.SetWindowBounds request");
  typename decltype(params->local_surface_id)::BaseType* local_surface_id_ptr;
  mojo::internal::Serialize<::cc::mojom::LocalSurfaceIdDataView>(
      in_local_surface_id, builder.buffer(), &local_surface_id_ptr, &serialization_context);
  params->local_surface_id.Set(local_surface_id_ptr);
  (&serialization_context)->handles.Swap(
      builder.message()->mutable_handles());
  (&serialization_context)->associated_endpoint_handles.swap(
      *builder.message()->mutable_associated_endpoint_handles());
  // This return value may be ignored as false implies the Connector has
  // encountered an error, which will be visible through other means.
  ignore_result(receiver_->Accept(builder.message()));
}

void WindowTreeProxy::SetClientArea(
    uint32_t in_window_id, ::gfx::mojom::blink::InsetsPtr in_insets, WTF::Optional<WTF::Vector<::gfx::mojom::blink::RectPtr>> in_additional_client_areas) {
  mojo::internal::SerializationContext serialization_context;
  size_t size = sizeof(::ui::mojom::internal::WindowTree_SetClientArea_Params_Data);
  size += mojo::internal::PrepareToSerialize<::gfx::mojom::InsetsDataView>(
      in_insets, &serialization_context);
  size += mojo::internal::PrepareToSerialize<mojo::ArrayDataView<::gfx::mojom::RectDataView>>(
      in_additional_client_areas, &serialization_context);
  constexpr uint32_t kFlags = 0;
  mojo::internal::MessageBuilder builder(
      internal::kWindowTree_SetClientArea_Name, kFlags, size,
      serialization_context.associated_endpoint_count);

  auto params =
      ::ui::mojom::internal::WindowTree_SetClientArea_Params_Data::New(builder.buffer());
  ALLOW_UNUSED_LOCAL(params);
  params->window_id = in_window_id;
  typename decltype(params->insets)::BaseType* insets_ptr;
  mojo::internal::Serialize<::gfx::mojom::InsetsDataView>(
      in_insets, builder.buffer(), &insets_ptr, &serialization_context);
  params->insets.Set(insets_ptr);
  MOJO_INTERNAL_DLOG_SERIALIZATION_WARNING(
      params->insets.is_null(),
      mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
      "null insets in WindowTree.SetClientArea request");
  typename decltype(params->additional_client_areas)::BaseType* additional_client_areas_ptr;
  const mojo::internal::ContainerValidateParams additional_client_areas_validate_params(
      0, false, nullptr);
  mojo::internal::Serialize<mojo::ArrayDataView<::gfx::mojom::RectDataView>>(
      in_additional_client_areas, builder.buffer(), &additional_client_areas_ptr, &additional_client_areas_validate_params,
      &serialization_context);
  params->additional_client_areas.Set(additional_client_areas_ptr);
  (&serialization_context)->handles.Swap(
      builder.message()->mutable_handles());
  (&serialization_context)->associated_endpoint_handles.swap(
      *builder.message()->mutable_associated_endpoint_handles());
  // This return value may be ignored as false implies the Connector has
  // encountered an error, which will be visible through other means.
  ignore_result(receiver_->Accept(builder.message()));
}

void WindowTreeProxy::SetHitTestMask(
    uint32_t in_window_id, ::gfx::mojom::blink::RectPtr in_mask) {
  mojo::internal::SerializationContext serialization_context;
  size_t size = sizeof(::ui::mojom::internal::WindowTree_SetHitTestMask_Params_Data);
  size += mojo::internal::PrepareToSerialize<::gfx::mojom::RectDataView>(
      in_mask, &serialization_context);
  constexpr uint32_t kFlags = 0;
  mojo::internal::MessageBuilder builder(
      internal::kWindowTree_SetHitTestMask_Name, kFlags, size,
      serialization_context.associated_endpoint_count);

  auto params =
      ::ui::mojom::internal::WindowTree_SetHitTestMask_Params_Data::New(builder.buffer());
  ALLOW_UNUSED_LOCAL(params);
  params->window_id = in_window_id;
  typename decltype(params->mask)::BaseType* mask_ptr;
  mojo::internal::Serialize<::gfx::mojom::RectDataView>(
      in_mask, builder.buffer(), &mask_ptr, &serialization_context);
  params->mask.Set(mask_ptr);
  (&serialization_context)->handles.Swap(
      builder.message()->mutable_handles());
  (&serialization_context)->associated_endpoint_handles.swap(
      *builder.message()->mutable_associated_endpoint_handles());
  // This return value may be ignored as false implies the Connector has
  // encountered an error, which will be visible through other means.
  ignore_result(receiver_->Accept(builder.message()));
}

void WindowTreeProxy::SetCanAcceptDrops(
    uint32_t in_window_id, bool in_accepts_drops) {
  mojo::internal::SerializationContext serialization_context;
  size_t size = sizeof(::ui::mojom::internal::WindowTree_SetCanAcceptDrops_Params_Data);
  constexpr uint32_t kFlags = 0;
  mojo::internal::MessageBuilder builder(
      internal::kWindowTree_SetCanAcceptDrops_Name, kFlags, size,
      serialization_context.associated_endpoint_count);

  auto params =
      ::ui::mojom::internal::WindowTree_SetCanAcceptDrops_Params_Data::New(builder.buffer());
  ALLOW_UNUSED_LOCAL(params);
  params->window_id = in_window_id;
  params->accepts_drops = in_accepts_drops;
  (&serialization_context)->handles.Swap(
      builder.message()->mutable_handles());
  (&serialization_context)->associated_endpoint_handles.swap(
      *builder.message()->mutable_associated_endpoint_handles());
  // This return value may be ignored as false implies the Connector has
  // encountered an error, which will be visible through other means.
  ignore_result(receiver_->Accept(builder.message()));
}

void WindowTreeProxy::SetWindowVisibility(
    uint32_t in_change_id, uint32_t in_window_id, bool in_visible) {
  mojo::internal::SerializationContext serialization_context;
  size_t size = sizeof(::ui::mojom::internal::WindowTree_SetWindowVisibility_Params_Data);
  constexpr uint32_t kFlags = 0;
  mojo::internal::MessageBuilder builder(
      internal::kWindowTree_SetWindowVisibility_Name, kFlags, size,
      serialization_context.associated_endpoint_count);

  auto params =
      ::ui::mojom::internal::WindowTree_SetWindowVisibility_Params_Data::New(builder.buffer());
  ALLOW_UNUSED_LOCAL(params);
  params->change_id = in_change_id;
  params->window_id = in_window_id;
  params->visible = in_visible;
  (&serialization_context)->handles.Swap(
      builder.message()->mutable_handles());
  (&serialization_context)->associated_endpoint_handles.swap(
      *builder.message()->mutable_associated_endpoint_handles());
  // This return value may be ignored as false implies the Connector has
  // encountered an error, which will be visible through other means.
  ignore_result(receiver_->Accept(builder.message()));
}

void WindowTreeProxy::SetWindowProperty(
    uint32_t in_change_id, uint32_t in_window_id, const WTF::String& in_name, const WTF::Optional<WTF::Vector<uint8_t>>& in_value) {
  mojo::internal::SerializationContext serialization_context;
  size_t size = sizeof(::ui::mojom::internal::WindowTree_SetWindowProperty_Params_Data);
  size += mojo::internal::PrepareToSerialize<mojo::StringDataView>(
      in_name, &serialization_context);
  size += mojo::internal::PrepareToSerialize<mojo::ArrayDataView<uint8_t>>(
      in_value, &serialization_context);
  constexpr uint32_t kFlags = 0;
  mojo::internal::MessageBuilder builder(
      internal::kWindowTree_SetWindowProperty_Name, kFlags, size,
      serialization_context.associated_endpoint_count);

  auto params =
      ::ui::mojom::internal::WindowTree_SetWindowProperty_Params_Data::New(builder.buffer());
  ALLOW_UNUSED_LOCAL(params);
  params->change_id = in_change_id;
  params->window_id = in_window_id;
  typename decltype(params->name)::BaseType* name_ptr;
  mojo::internal::Serialize<mojo::StringDataView>(
      in_name, builder.buffer(), &name_ptr, &serialization_context);
  params->name.Set(name_ptr);
  MOJO_INTERNAL_DLOG_SERIALIZATION_WARNING(
      params->name.is_null(),
      mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
      "null name in WindowTree.SetWindowProperty request");
  typename decltype(params->value)::BaseType* value_ptr;
  const mojo::internal::ContainerValidateParams value_validate_params(
      0, false, nullptr);
  mojo::internal::Serialize<mojo::ArrayDataView<uint8_t>>(
      in_value, builder.buffer(), &value_ptr, &value_validate_params,
      &serialization_context);
  params->value.Set(value_ptr);
  (&serialization_context)->handles.Swap(
      builder.message()->mutable_handles());
  (&serialization_context)->associated_endpoint_handles.swap(
      *builder.message()->mutable_associated_endpoint_handles());
  // This return value may be ignored as false implies the Connector has
  // encountered an error, which will be visible through other means.
  ignore_result(receiver_->Accept(builder.message()));
}

void WindowTreeProxy::SetWindowOpacity(
    uint32_t in_change_id, uint32_t in_window_id, float in_opacity) {
  mojo::internal::SerializationContext serialization_context;
  size_t size = sizeof(::ui::mojom::internal::WindowTree_SetWindowOpacity_Params_Data);
  constexpr uint32_t kFlags = 0;
  mojo::internal::MessageBuilder builder(
      internal::kWindowTree_SetWindowOpacity_Name, kFlags, size,
      serialization_context.associated_endpoint_count);

  auto params =
      ::ui::mojom::internal::WindowTree_SetWindowOpacity_Params_Data::New(builder.buffer());
  ALLOW_UNUSED_LOCAL(params);
  params->change_id = in_change_id;
  params->window_id = in_window_id;
  params->opacity = in_opacity;
  (&serialization_context)->handles.Swap(
      builder.message()->mutable_handles());
  (&serialization_context)->associated_endpoint_handles.swap(
      *builder.message()->mutable_associated_endpoint_handles());
  // This return value may be ignored as false implies the Connector has
  // encountered an error, which will be visible through other means.
  ignore_result(receiver_->Accept(builder.message()));
}

void WindowTreeProxy::AttachCompositorFrameSink(
    uint32_t in_window_id, ::cc::mojom::blink::MojoCompositorFrameSinkRequest in_compositor_frame_sink, ::cc::mojom::blink::MojoCompositorFrameSinkClientPtr in_client) {
  mojo::internal::SerializationContext serialization_context;
  size_t size = sizeof(::ui::mojom::internal::WindowTree_AttachCompositorFrameSink_Params_Data);
  constexpr uint32_t kFlags = 0;
  mojo::internal::MessageBuilder builder(
      internal::kWindowTree_AttachCompositorFrameSink_Name, kFlags, size,
      serialization_context.associated_endpoint_count);

  auto params =
      ::ui::mojom::internal::WindowTree_AttachCompositorFrameSink_Params_Data::New(builder.buffer());
  ALLOW_UNUSED_LOCAL(params);
  params->window_id = in_window_id;
  mojo::internal::Serialize<::cc::mojom::MojoCompositorFrameSinkRequestDataView>(
      in_compositor_frame_sink, &params->compositor_frame_sink, &serialization_context);
  MOJO_INTERNAL_DLOG_SERIALIZATION_WARNING(
      !mojo::internal::IsHandleOrInterfaceValid(params->compositor_frame_sink),
      mojo::internal::VALIDATION_ERROR_UNEXPECTED_INVALID_HANDLE,
      "invalid compositor_frame_sink in WindowTree.AttachCompositorFrameSink request");
  mojo::internal::Serialize<::cc::mojom::MojoCompositorFrameSinkClientPtrDataView>(
      in_client, &params->client, &serialization_context);
  MOJO_INTERNAL_DLOG_SERIALIZATION_WARNING(
      !mojo::internal::IsHandleOrInterfaceValid(params->client),
      mojo::internal::VALIDATION_ERROR_UNEXPECTED_INVALID_HANDLE,
      "invalid client in WindowTree.AttachCompositorFrameSink request");
  (&serialization_context)->handles.Swap(
      builder.message()->mutable_handles());
  (&serialization_context)->associated_endpoint_handles.swap(
      *builder.message()->mutable_associated_endpoint_handles());
  // This return value may be ignored as false implies the Connector has
  // encountered an error, which will be visible through other means.
  ignore_result(receiver_->Accept(builder.message()));
}

void WindowTreeProxy::AddWindow(
    uint32_t in_change_id, uint32_t in_parent, uint32_t in_child) {
  mojo::internal::SerializationContext serialization_context;
  size_t size = sizeof(::ui::mojom::internal::WindowTree_AddWindow_Params_Data);
  constexpr uint32_t kFlags = 0;
  mojo::internal::MessageBuilder builder(
      internal::kWindowTree_AddWindow_Name, kFlags, size,
      serialization_context.associated_endpoint_count);

  auto params =
      ::ui::mojom::internal::WindowTree_AddWindow_Params_Data::New(builder.buffer());
  ALLOW_UNUSED_LOCAL(params);
  params->change_id = in_change_id;
  params->parent = in_parent;
  params->child = in_child;
  (&serialization_context)->handles.Swap(
      builder.message()->mutable_handles());
  (&serialization_context)->associated_endpoint_handles.swap(
      *builder.message()->mutable_associated_endpoint_handles());
  // This return value may be ignored as false implies the Connector has
  // encountered an error, which will be visible through other means.
  ignore_result(receiver_->Accept(builder.message()));
}

void WindowTreeProxy::RemoveWindowFromParent(
    uint32_t in_change_id, uint32_t in_window_id) {
  mojo::internal::SerializationContext serialization_context;
  size_t size = sizeof(::ui::mojom::internal::WindowTree_RemoveWindowFromParent_Params_Data);
  constexpr uint32_t kFlags = 0;
  mojo::internal::MessageBuilder builder(
      internal::kWindowTree_RemoveWindowFromParent_Name, kFlags, size,
      serialization_context.associated_endpoint_count);

  auto params =
      ::ui::mojom::internal::WindowTree_RemoveWindowFromParent_Params_Data::New(builder.buffer());
  ALLOW_UNUSED_LOCAL(params);
  params->change_id = in_change_id;
  params->window_id = in_window_id;
  (&serialization_context)->handles.Swap(
      builder.message()->mutable_handles());
  (&serialization_context)->associated_endpoint_handles.swap(
      *builder.message()->mutable_associated_endpoint_handles());
  // This return value may be ignored as false implies the Connector has
  // encountered an error, which will be visible through other means.
  ignore_result(receiver_->Accept(builder.message()));
}

void WindowTreeProxy::AddTransientWindow(
    uint32_t in_change_id, uint32_t in_window_id, uint32_t in_transient_window_id) {
  mojo::internal::SerializationContext serialization_context;
  size_t size = sizeof(::ui::mojom::internal::WindowTree_AddTransientWindow_Params_Data);
  constexpr uint32_t kFlags = 0;
  mojo::internal::MessageBuilder builder(
      internal::kWindowTree_AddTransientWindow_Name, kFlags, size,
      serialization_context.associated_endpoint_count);

  auto params =
      ::ui::mojom::internal::WindowTree_AddTransientWindow_Params_Data::New(builder.buffer());
  ALLOW_UNUSED_LOCAL(params);
  params->change_id = in_change_id;
  params->window_id = in_window_id;
  params->transient_window_id = in_transient_window_id;
  (&serialization_context)->handles.Swap(
      builder.message()->mutable_handles());
  (&serialization_context)->associated_endpoint_handles.swap(
      *builder.message()->mutable_associated_endpoint_handles());
  // This return value may be ignored as false implies the Connector has
  // encountered an error, which will be visible through other means.
  ignore_result(receiver_->Accept(builder.message()));
}

void WindowTreeProxy::RemoveTransientWindowFromParent(
    uint32_t in_change_id, uint32_t in_transient_window_id) {
  mojo::internal::SerializationContext serialization_context;
  size_t size = sizeof(::ui::mojom::internal::WindowTree_RemoveTransientWindowFromParent_Params_Data);
  constexpr uint32_t kFlags = 0;
  mojo::internal::MessageBuilder builder(
      internal::kWindowTree_RemoveTransientWindowFromParent_Name, kFlags, size,
      serialization_context.associated_endpoint_count);

  auto params =
      ::ui::mojom::internal::WindowTree_RemoveTransientWindowFromParent_Params_Data::New(builder.buffer());
  ALLOW_UNUSED_LOCAL(params);
  params->change_id = in_change_id;
  params->transient_window_id = in_transient_window_id;
  (&serialization_context)->handles.Swap(
      builder.message()->mutable_handles());
  (&serialization_context)->associated_endpoint_handles.swap(
      *builder.message()->mutable_associated_endpoint_handles());
  // This return value may be ignored as false implies the Connector has
  // encountered an error, which will be visible through other means.
  ignore_result(receiver_->Accept(builder.message()));
}

void WindowTreeProxy::SetModalType(
    uint32_t in_change_id, uint32_t in_window_id, ::ui::mojom::blink::ModalType in_type) {
  mojo::internal::SerializationContext serialization_context;
  size_t size = sizeof(::ui::mojom::internal::WindowTree_SetModalType_Params_Data);
  constexpr uint32_t kFlags = 0;
  mojo::internal::MessageBuilder builder(
      internal::kWindowTree_SetModalType_Name, kFlags, size,
      serialization_context.associated_endpoint_count);

  auto params =
      ::ui::mojom::internal::WindowTree_SetModalType_Params_Data::New(builder.buffer());
  ALLOW_UNUSED_LOCAL(params);
  params->change_id = in_change_id;
  params->window_id = in_window_id;
  mojo::internal::Serialize<::ui::mojom::ModalType>(
      in_type, &params->type);
  (&serialization_context)->handles.Swap(
      builder.message()->mutable_handles());
  (&serialization_context)->associated_endpoint_handles.swap(
      *builder.message()->mutable_associated_endpoint_handles());
  // This return value may be ignored as false implies the Connector has
  // encountered an error, which will be visible through other means.
  ignore_result(receiver_->Accept(builder.message()));
}

void WindowTreeProxy::ReorderWindow(
    uint32_t in_change_id, uint32_t in_window_id, uint32_t in_relative_window_id, ::ui::mojom::blink::OrderDirection in_direction) {
  mojo::internal::SerializationContext serialization_context;
  size_t size = sizeof(::ui::mojom::internal::WindowTree_ReorderWindow_Params_Data);
  constexpr uint32_t kFlags = 0;
  mojo::internal::MessageBuilder builder(
      internal::kWindowTree_ReorderWindow_Name, kFlags, size,
      serialization_context.associated_endpoint_count);

  auto params =
      ::ui::mojom::internal::WindowTree_ReorderWindow_Params_Data::New(builder.buffer());
  ALLOW_UNUSED_LOCAL(params);
  params->change_id = in_change_id;
  params->window_id = in_window_id;
  params->relative_window_id = in_relative_window_id;
  mojo::internal::Serialize<::ui::mojom::OrderDirection>(
      in_direction, &params->direction);
  (&serialization_context)->handles.Swap(
      builder.message()->mutable_handles());
  (&serialization_context)->associated_endpoint_handles.swap(
      *builder.message()->mutable_associated_endpoint_handles());
  // This return value may be ignored as false implies the Connector has
  // encountered an error, which will be visible through other means.
  ignore_result(receiver_->Accept(builder.message()));
}

void WindowTreeProxy::GetWindowTree(
    uint32_t in_window_id, const GetWindowTreeCallback& callback) {
  mojo::internal::SerializationContext serialization_context;
  size_t size = sizeof(::ui::mojom::internal::WindowTree_GetWindowTree_Params_Data);
  constexpr uint32_t kFlags = mojo::Message::kFlagExpectsResponse;
  mojo::internal::MessageBuilder builder(
      internal::kWindowTree_GetWindowTree_Name, kFlags, size,
      serialization_context.associated_endpoint_count);

  auto params =
      ::ui::mojom::internal::WindowTree_GetWindowTree_Params_Data::New(builder.buffer());
  ALLOW_UNUSED_LOCAL(params);
  params->window_id = in_window_id;
  (&serialization_context)->handles.Swap(
      builder.message()->mutable_handles());
  (&serialization_context)->associated_endpoint_handles.swap(
      *builder.message()->mutable_associated_endpoint_handles());
  std::unique_ptr<mojo::MessageReceiver> responder(
      new WindowTree_GetWindowTree_ForwardToCallback(
          std::move(callback)));
  ignore_result(receiver_->AcceptWithResponder(builder.message(),
                                               std::move(responder)));
}

void WindowTreeProxy::Embed(
    uint32_t in_window_id, WindowTreeClientPtr in_client, uint32_t in_embed_flags, const EmbedCallback& callback) {
  mojo::internal::SerializationContext serialization_context;
  size_t size = sizeof(::ui::mojom::internal::WindowTree_Embed_Params_Data);
  constexpr uint32_t kFlags = mojo::Message::kFlagExpectsResponse;
  mojo::internal::MessageBuilder builder(
      internal::kWindowTree_Embed_Name, kFlags, size,
      serialization_context.associated_endpoint_count);

  auto params =
      ::ui::mojom::internal::WindowTree_Embed_Params_Data::New(builder.buffer());
  ALLOW_UNUSED_LOCAL(params);
  params->window_id = in_window_id;
  mojo::internal::Serialize<::ui::mojom::WindowTreeClientPtrDataView>(
      in_client, &params->client, &serialization_context);
  MOJO_INTERNAL_DLOG_SERIALIZATION_WARNING(
      !mojo::internal::IsHandleOrInterfaceValid(params->client),
      mojo::internal::VALIDATION_ERROR_UNEXPECTED_INVALID_HANDLE,
      "invalid client in WindowTree.Embed request");
  params->embed_flags = in_embed_flags;
  (&serialization_context)->handles.Swap(
      builder.message()->mutable_handles());
  (&serialization_context)->associated_endpoint_handles.swap(
      *builder.message()->mutable_associated_endpoint_handles());
  std::unique_ptr<mojo::MessageReceiver> responder(
      new WindowTree_Embed_ForwardToCallback(
          std::move(callback)));
  ignore_result(receiver_->AcceptWithResponder(builder.message(),
                                               std::move(responder)));
}

void WindowTreeProxy::SetFocus(
    uint32_t in_change_id, uint32_t in_window_id) {
  mojo::internal::SerializationContext serialization_context;
  size_t size = sizeof(::ui::mojom::internal::WindowTree_SetFocus_Params_Data);
  constexpr uint32_t kFlags = 0;
  mojo::internal::MessageBuilder builder(
      internal::kWindowTree_SetFocus_Name, kFlags, size,
      serialization_context.associated_endpoint_count);

  auto params =
      ::ui::mojom::internal::WindowTree_SetFocus_Params_Data::New(builder.buffer());
  ALLOW_UNUSED_LOCAL(params);
  params->change_id = in_change_id;
  params->window_id = in_window_id;
  (&serialization_context)->handles.Swap(
      builder.message()->mutable_handles());
  (&serialization_context)->associated_endpoint_handles.swap(
      *builder.message()->mutable_associated_endpoint_handles());
  // This return value may be ignored as false implies the Connector has
  // encountered an error, which will be visible through other means.
  ignore_result(receiver_->Accept(builder.message()));
}

void WindowTreeProxy::SetCanFocus(
    uint32_t in_window_id, bool in_can_focus) {
  mojo::internal::SerializationContext serialization_context;
  size_t size = sizeof(::ui::mojom::internal::WindowTree_SetCanFocus_Params_Data);
  constexpr uint32_t kFlags = 0;
  mojo::internal::MessageBuilder builder(
      internal::kWindowTree_SetCanFocus_Name, kFlags, size,
      serialization_context.associated_endpoint_count);

  auto params =
      ::ui::mojom::internal::WindowTree_SetCanFocus_Params_Data::New(builder.buffer());
  ALLOW_UNUSED_LOCAL(params);
  params->window_id = in_window_id;
  params->can_focus = in_can_focus;
  (&serialization_context)->handles.Swap(
      builder.message()->mutable_handles());
  (&serialization_context)->associated_endpoint_handles.swap(
      *builder.message()->mutable_associated_endpoint_handles());
  // This return value may be ignored as false implies the Connector has
  // encountered an error, which will be visible through other means.
  ignore_result(receiver_->Accept(builder.message()));
}

void WindowTreeProxy::SetCursor(
    uint32_t in_change_id, uint32_t in_window_id, ::ui::mojom::blink::CursorDataPtr in_cursor) {
  mojo::internal::SerializationContext serialization_context;
  size_t size = sizeof(::ui::mojom::internal::WindowTree_SetCursor_Params_Data);
  size += mojo::internal::PrepareToSerialize<::ui::mojom::CursorDataDataView>(
      in_cursor, &serialization_context);
  constexpr uint32_t kFlags = 0;
  mojo::internal::MessageBuilder builder(
      internal::kWindowTree_SetCursor_Name, kFlags, size,
      serialization_context.associated_endpoint_count);

  auto params =
      ::ui::mojom::internal::WindowTree_SetCursor_Params_Data::New(builder.buffer());
  ALLOW_UNUSED_LOCAL(params);
  params->change_id = in_change_id;
  params->window_id = in_window_id;
  typename decltype(params->cursor)::BaseType* cursor_ptr;
  mojo::internal::Serialize<::ui::mojom::CursorDataDataView>(
      in_cursor, builder.buffer(), &cursor_ptr, &serialization_context);
  params->cursor.Set(cursor_ptr);
  MOJO_INTERNAL_DLOG_SERIALIZATION_WARNING(
      params->cursor.is_null(),
      mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
      "null cursor in WindowTree.SetCursor request");
  (&serialization_context)->handles.Swap(
      builder.message()->mutable_handles());
  (&serialization_context)->associated_endpoint_handles.swap(
      *builder.message()->mutable_associated_endpoint_handles());
  // This return value may be ignored as false implies the Connector has
  // encountered an error, which will be visible through other means.
  ignore_result(receiver_->Accept(builder.message()));
}

void WindowTreeProxy::SetWindowTextInputState(
    uint32_t in_window_id, ::mojo::blink::TextInputStatePtr in_state) {
  mojo::internal::SerializationContext serialization_context;
  size_t size = sizeof(::ui::mojom::internal::WindowTree_SetWindowTextInputState_Params_Data);
  size += mojo::internal::PrepareToSerialize<::mojo::TextInputStateDataView>(
      in_state, &serialization_context);
  constexpr uint32_t kFlags = 0;
  mojo::internal::MessageBuilder builder(
      internal::kWindowTree_SetWindowTextInputState_Name, kFlags, size,
      serialization_context.associated_endpoint_count);

  auto params =
      ::ui::mojom::internal::WindowTree_SetWindowTextInputState_Params_Data::New(builder.buffer());
  ALLOW_UNUSED_LOCAL(params);
  params->window_id = in_window_id;
  typename decltype(params->state)::BaseType* state_ptr;
  mojo::internal::Serialize<::mojo::TextInputStateDataView>(
      in_state, builder.buffer(), &state_ptr, &serialization_context);
  params->state.Set(state_ptr);
  MOJO_INTERNAL_DLOG_SERIALIZATION_WARNING(
      params->state.is_null(),
      mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
      "null state in WindowTree.SetWindowTextInputState request");
  (&serialization_context)->handles.Swap(
      builder.message()->mutable_handles());
  (&serialization_context)->associated_endpoint_handles.swap(
      *builder.message()->mutable_associated_endpoint_handles());
  // This return value may be ignored as false implies the Connector has
  // encountered an error, which will be visible through other means.
  ignore_result(receiver_->Accept(builder.message()));
}

void WindowTreeProxy::SetImeVisibility(
    uint32_t in_window_id, bool in_visible, ::mojo::blink::TextInputStatePtr in_state) {
  mojo::internal::SerializationContext serialization_context;
  size_t size = sizeof(::ui::mojom::internal::WindowTree_SetImeVisibility_Params_Data);
  size += mojo::internal::PrepareToSerialize<::mojo::TextInputStateDataView>(
      in_state, &serialization_context);
  constexpr uint32_t kFlags = 0;
  mojo::internal::MessageBuilder builder(
      internal::kWindowTree_SetImeVisibility_Name, kFlags, size,
      serialization_context.associated_endpoint_count);

  auto params =
      ::ui::mojom::internal::WindowTree_SetImeVisibility_Params_Data::New(builder.buffer());
  ALLOW_UNUSED_LOCAL(params);
  params->window_id = in_window_id;
  params->visible = in_visible;
  typename decltype(params->state)::BaseType* state_ptr;
  mojo::internal::Serialize<::mojo::TextInputStateDataView>(
      in_state, builder.buffer(), &state_ptr, &serialization_context);
  params->state.Set(state_ptr);
  (&serialization_context)->handles.Swap(
      builder.message()->mutable_handles());
  (&serialization_context)->associated_endpoint_handles.swap(
      *builder.message()->mutable_associated_endpoint_handles());
  // This return value may be ignored as false implies the Connector has
  // encountered an error, which will be visible through other means.
  ignore_result(receiver_->Accept(builder.message()));
}

void WindowTreeProxy::SetEventTargetingPolicy(
    uint32_t in_window_id, ::ui::mojom::blink::EventTargetingPolicy in_policy) {
  mojo::internal::SerializationContext serialization_context;
  size_t size = sizeof(::ui::mojom::internal::WindowTree_SetEventTargetingPolicy_Params_Data);
  constexpr uint32_t kFlags = 0;
  mojo::internal::MessageBuilder builder(
      internal::kWindowTree_SetEventTargetingPolicy_Name, kFlags, size,
      serialization_context.associated_endpoint_count);

  auto params =
      ::ui::mojom::internal::WindowTree_SetEventTargetingPolicy_Params_Data::New(builder.buffer());
  ALLOW_UNUSED_LOCAL(params);
  params->window_id = in_window_id;
  mojo::internal::Serialize<::ui::mojom::EventTargetingPolicy>(
      in_policy, &params->policy);
  (&serialization_context)->handles.Swap(
      builder.message()->mutable_handles());
  (&serialization_context)->associated_endpoint_handles.swap(
      *builder.message()->mutable_associated_endpoint_handles());
  // This return value may be ignored as false implies the Connector has
  // encountered an error, which will be visible through other means.
  ignore_result(receiver_->Accept(builder.message()));
}

void WindowTreeProxy::OnWindowInputEventAck(
    uint32_t in_event_id, ::ui::mojom::blink::EventResult in_result) {
  mojo::internal::SerializationContext serialization_context;
  size_t size = sizeof(::ui::mojom::internal::WindowTree_OnWindowInputEventAck_Params_Data);
  constexpr uint32_t kFlags = 0;
  mojo::internal::MessageBuilder builder(
      internal::kWindowTree_OnWindowInputEventAck_Name, kFlags, size,
      serialization_context.associated_endpoint_count);

  auto params =
      ::ui::mojom::internal::WindowTree_OnWindowInputEventAck_Params_Data::New(builder.buffer());
  ALLOW_UNUSED_LOCAL(params);
  params->event_id = in_event_id;
  mojo::internal::Serialize<::ui::mojom::EventResult>(
      in_result, &params->result);
  (&serialization_context)->handles.Swap(
      builder.message()->mutable_handles());
  (&serialization_context)->associated_endpoint_handles.swap(
      *builder.message()->mutable_associated_endpoint_handles());
  // This return value may be ignored as false implies the Connector has
  // encountered an error, which will be visible through other means.
  ignore_result(receiver_->Accept(builder.message()));
}

void WindowTreeProxy::DeactivateWindow(
    uint32_t in_window_id) {
  mojo::internal::SerializationContext serialization_context;
  size_t size = sizeof(::ui::mojom::internal::WindowTree_DeactivateWindow_Params_Data);
  constexpr uint32_t kFlags = 0;
  mojo::internal::MessageBuilder builder(
      internal::kWindowTree_DeactivateWindow_Name, kFlags, size,
      serialization_context.associated_endpoint_count);

  auto params =
      ::ui::mojom::internal::WindowTree_DeactivateWindow_Params_Data::New(builder.buffer());
  ALLOW_UNUSED_LOCAL(params);
  params->window_id = in_window_id;
  (&serialization_context)->handles.Swap(
      builder.message()->mutable_handles());
  (&serialization_context)->associated_endpoint_handles.swap(
      *builder.message()->mutable_associated_endpoint_handles());
  // This return value may be ignored as false implies the Connector has
  // encountered an error, which will be visible through other means.
  ignore_result(receiver_->Accept(builder.message()));
}

void WindowTreeProxy::StackAbove(
    uint32_t in_change_id, uint32_t in_above_id, uint32_t in_below_id) {
  mojo::internal::SerializationContext serialization_context;
  size_t size = sizeof(::ui::mojom::internal::WindowTree_StackAbove_Params_Data);
  constexpr uint32_t kFlags = 0;
  mojo::internal::MessageBuilder builder(
      internal::kWindowTree_StackAbove_Name, kFlags, size,
      serialization_context.associated_endpoint_count);

  auto params =
      ::ui::mojom::internal::WindowTree_StackAbove_Params_Data::New(builder.buffer());
  ALLOW_UNUSED_LOCAL(params);
  params->change_id = in_change_id;
  params->above_id = in_above_id;
  params->below_id = in_below_id;
  (&serialization_context)->handles.Swap(
      builder.message()->mutable_handles());
  (&serialization_context)->associated_endpoint_handles.swap(
      *builder.message()->mutable_associated_endpoint_handles());
  // This return value may be ignored as false implies the Connector has
  // encountered an error, which will be visible through other means.
  ignore_result(receiver_->Accept(builder.message()));
}

void WindowTreeProxy::StackAtTop(
    uint32_t in_change_id, uint32_t in_window_id) {
  mojo::internal::SerializationContext serialization_context;
  size_t size = sizeof(::ui::mojom::internal::WindowTree_StackAtTop_Params_Data);
  constexpr uint32_t kFlags = 0;
  mojo::internal::MessageBuilder builder(
      internal::kWindowTree_StackAtTop_Name, kFlags, size,
      serialization_context.associated_endpoint_count);

  auto params =
      ::ui::mojom::internal::WindowTree_StackAtTop_Params_Data::New(builder.buffer());
  ALLOW_UNUSED_LOCAL(params);
  params->change_id = in_change_id;
  params->window_id = in_window_id;
  (&serialization_context)->handles.Swap(
      builder.message()->mutable_handles());
  (&serialization_context)->associated_endpoint_handles.swap(
      *builder.message()->mutable_associated_endpoint_handles());
  // This return value may be ignored as false implies the Connector has
  // encountered an error, which will be visible through other means.
  ignore_result(receiver_->Accept(builder.message()));
}

void WindowTreeProxy::GetWindowManagerClient(
    ::ui::mojom::blink::WindowManagerClientAssociatedRequest in_internal) {
  mojo::internal::SerializationContext serialization_context;
  size_t size = sizeof(::ui::mojom::internal::WindowTree_GetWindowManagerClient_Params_Data);
  size += mojo::internal::PrepareToSerialize<::ui::mojom::WindowManagerClientAssociatedRequestDataView>(
      in_internal, &serialization_context);
  constexpr uint32_t kFlags = 0;
  mojo::internal::MessageBuilder builder(
      internal::kWindowTree_GetWindowManagerClient_Name, kFlags, size,
      serialization_context.associated_endpoint_count);

  auto params =
      ::ui::mojom::internal::WindowTree_GetWindowManagerClient_Params_Data::New(builder.buffer());
  ALLOW_UNUSED_LOCAL(params);
  mojo::internal::Serialize<::ui::mojom::WindowManagerClientAssociatedRequestDataView>(
      in_internal, &params->internal, &serialization_context);
  MOJO_INTERNAL_DLOG_SERIALIZATION_WARNING(
      !mojo::internal::IsHandleOrInterfaceValid(params->internal),
      mojo::internal::VALIDATION_ERROR_UNEXPECTED_INVALID_INTERFACE_ID,
      "invalid internal in WindowTree.GetWindowManagerClient request");
  (&serialization_context)->handles.Swap(
      builder.message()->mutable_handles());
  (&serialization_context)->associated_endpoint_handles.swap(
      *builder.message()->mutable_associated_endpoint_handles());
  // This return value may be ignored as false implies the Connector has
  // encountered an error, which will be visible through other means.
  ignore_result(receiver_->Accept(builder.message()));
}

void WindowTreeProxy::GetCursorLocationMemory(
    const GetCursorLocationMemoryCallback& callback) {
  mojo::internal::SerializationContext serialization_context;
  size_t size = sizeof(::ui::mojom::internal::WindowTree_GetCursorLocationMemory_Params_Data);
  constexpr uint32_t kFlags = mojo::Message::kFlagExpectsResponse;
  mojo::internal::MessageBuilder builder(
      internal::kWindowTree_GetCursorLocationMemory_Name, kFlags, size,
      serialization_context.associated_endpoint_count);

  auto params =
      ::ui::mojom::internal::WindowTree_GetCursorLocationMemory_Params_Data::New(builder.buffer());
  ALLOW_UNUSED_LOCAL(params);
  (&serialization_context)->handles.Swap(
      builder.message()->mutable_handles());
  (&serialization_context)->associated_endpoint_handles.swap(
      *builder.message()->mutable_associated_endpoint_handles());
  std::unique_ptr<mojo::MessageReceiver> responder(
      new WindowTree_GetCursorLocationMemory_ForwardToCallback(
          std::move(callback)));
  ignore_result(receiver_->AcceptWithResponder(builder.message(),
                                               std::move(responder)));
}

void WindowTreeProxy::PerformWindowMove(
    uint32_t in_change_id, uint32_t in_window_id, ::ui::mojom::blink::MoveLoopSource in_source, ::gfx::mojom::blink::PointPtr in_cursor) {
  mojo::internal::SerializationContext serialization_context;
  size_t size = sizeof(::ui::mojom::internal::WindowTree_PerformWindowMove_Params_Data);
  size += mojo::internal::PrepareToSerialize<::gfx::mojom::PointDataView>(
      in_cursor, &serialization_context);
  constexpr uint32_t kFlags = 0;
  mojo::internal::MessageBuilder builder(
      internal::kWindowTree_PerformWindowMove_Name, kFlags, size,
      serialization_context.associated_endpoint_count);

  auto params =
      ::ui::mojom::internal::WindowTree_PerformWindowMove_Params_Data::New(builder.buffer());
  ALLOW_UNUSED_LOCAL(params);
  params->change_id = in_change_id;
  params->window_id = in_window_id;
  mojo::internal::Serialize<::ui::mojom::MoveLoopSource>(
      in_source, &params->source);
  typename decltype(params->cursor)::BaseType* cursor_ptr;
  mojo::internal::Serialize<::gfx::mojom::PointDataView>(
      in_cursor, builder.buffer(), &cursor_ptr, &serialization_context);
  params->cursor.Set(cursor_ptr);
  MOJO_INTERNAL_DLOG_SERIALIZATION_WARNING(
      params->cursor.is_null(),
      mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
      "null cursor in WindowTree.PerformWindowMove request");
  (&serialization_context)->handles.Swap(
      builder.message()->mutable_handles());
  (&serialization_context)->associated_endpoint_handles.swap(
      *builder.message()->mutable_associated_endpoint_handles());
  // This return value may be ignored as false implies the Connector has
  // encountered an error, which will be visible through other means.
  ignore_result(receiver_->Accept(builder.message()));
}

void WindowTreeProxy::CancelWindowMove(
    uint32_t in_window_id) {
  mojo::internal::SerializationContext serialization_context;
  size_t size = sizeof(::ui::mojom::internal::WindowTree_CancelWindowMove_Params_Data);
  constexpr uint32_t kFlags = 0;
  mojo::internal::MessageBuilder builder(
      internal::kWindowTree_CancelWindowMove_Name, kFlags, size,
      serialization_context.associated_endpoint_count);

  auto params =
      ::ui::mojom::internal::WindowTree_CancelWindowMove_Params_Data::New(builder.buffer());
  ALLOW_UNUSED_LOCAL(params);
  params->window_id = in_window_id;
  (&serialization_context)->handles.Swap(
      builder.message()->mutable_handles());
  (&serialization_context)->associated_endpoint_handles.swap(
      *builder.message()->mutable_associated_endpoint_handles());
  // This return value may be ignored as false implies the Connector has
  // encountered an error, which will be visible through other means.
  ignore_result(receiver_->Accept(builder.message()));
}

void WindowTreeProxy::PerformDragDrop(
    uint32_t in_change_id, uint32_t in_source_window_id, ::gfx::mojom::blink::PointPtr in_screen_location, const WTF::HashMap<WTF::String, WTF::Vector<uint8_t>>& in_drag_data, ::skia::mojom::blink::BitmapPtr in_drag_image, ::gfx::mojom::blink::Vector2dPtr in_drag_image_offset, uint32_t in_drag_operation, ::ui::mojom::blink::PointerKind in_source) {
  mojo::internal::SerializationContext serialization_context;
  size_t size = sizeof(::ui::mojom::internal::WindowTree_PerformDragDrop_Params_Data);
  size += mojo::internal::PrepareToSerialize<::gfx::mojom::PointDataView>(
      in_screen_location, &serialization_context);
  size += mojo::internal::PrepareToSerialize<mojo::MapDataView<mojo::StringDataView, mojo::ArrayDataView<uint8_t>>>(
      in_drag_data, &serialization_context);
  size += mojo::internal::PrepareToSerialize<::skia::mojom::BitmapDataView>(
      in_drag_image, &serialization_context);
  size += mojo::internal::PrepareToSerialize<::gfx::mojom::Vector2dDataView>(
      in_drag_image_offset, &serialization_context);
  constexpr uint32_t kFlags = 0;
  mojo::internal::MessageBuilder builder(
      internal::kWindowTree_PerformDragDrop_Name, kFlags, size,
      serialization_context.associated_endpoint_count);

  auto params =
      ::ui::mojom::internal::WindowTree_PerformDragDrop_Params_Data::New(builder.buffer());
  ALLOW_UNUSED_LOCAL(params);
  params->change_id = in_change_id;
  params->source_window_id = in_source_window_id;
  typename decltype(params->screen_location)::BaseType* screen_location_ptr;
  mojo::internal::Serialize<::gfx::mojom::PointDataView>(
      in_screen_location, builder.buffer(), &screen_location_ptr, &serialization_context);
  params->screen_location.Set(screen_location_ptr);
  MOJO_INTERNAL_DLOG_SERIALIZATION_WARNING(
      params->screen_location.is_null(),
      mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
      "null screen_location in WindowTree.PerformDragDrop request");
  typename decltype(params->drag_data)::BaseType* drag_data_ptr;
  const mojo::internal::ContainerValidateParams drag_data_validate_params(
      new mojo::internal::ContainerValidateParams(0, false, new mojo::internal::ContainerValidateParams(0, false, nullptr)), new mojo::internal::ContainerValidateParams(0, false, new mojo::internal::ContainerValidateParams(0, false, nullptr)));
  mojo::internal::Serialize<mojo::MapDataView<mojo::StringDataView, mojo::ArrayDataView<uint8_t>>>(
      in_drag_data, builder.buffer(), &drag_data_ptr, &drag_data_validate_params,
      &serialization_context);
  params->drag_data.Set(drag_data_ptr);
  MOJO_INTERNAL_DLOG_SERIALIZATION_WARNING(
      params->drag_data.is_null(),
      mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
      "null drag_data in WindowTree.PerformDragDrop request");
  typename decltype(params->drag_image)::BaseType* drag_image_ptr;
  mojo::internal::Serialize<::skia::mojom::BitmapDataView>(
      in_drag_image, builder.buffer(), &drag_image_ptr, &serialization_context);
  params->drag_image.Set(drag_image_ptr);
  typename decltype(params->drag_image_offset)::BaseType* drag_image_offset_ptr;
  mojo::internal::Serialize<::gfx::mojom::Vector2dDataView>(
      in_drag_image_offset, builder.buffer(), &drag_image_offset_ptr, &serialization_context);
  params->drag_image_offset.Set(drag_image_offset_ptr);
  MOJO_INTERNAL_DLOG_SERIALIZATION_WARNING(
      params->drag_image_offset.is_null(),
      mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
      "null drag_image_offset in WindowTree.PerformDragDrop request");
  params->drag_operation = in_drag_operation;
  mojo::internal::Serialize<::ui::mojom::PointerKind>(
      in_source, &params->source);
  (&serialization_context)->handles.Swap(
      builder.message()->mutable_handles());
  (&serialization_context)->associated_endpoint_handles.swap(
      *builder.message()->mutable_associated_endpoint_handles());
  // This return value may be ignored as false implies the Connector has
  // encountered an error, which will be visible through other means.
  ignore_result(receiver_->Accept(builder.message()));
}

void WindowTreeProxy::CancelDragDrop(
    uint32_t in_window_id) {
  mojo::internal::SerializationContext serialization_context;
  size_t size = sizeof(::ui::mojom::internal::WindowTree_CancelDragDrop_Params_Data);
  constexpr uint32_t kFlags = 0;
  mojo::internal::MessageBuilder builder(
      internal::kWindowTree_CancelDragDrop_Name, kFlags, size,
      serialization_context.associated_endpoint_count);

  auto params =
      ::ui::mojom::internal::WindowTree_CancelDragDrop_Params_Data::New(builder.buffer());
  ALLOW_UNUSED_LOCAL(params);
  params->window_id = in_window_id;
  (&serialization_context)->handles.Swap(
      builder.message()->mutable_handles());
  (&serialization_context)->associated_endpoint_handles.swap(
      *builder.message()->mutable_associated_endpoint_handles());
  // This return value may be ignored as false implies the Connector has
  // encountered an error, which will be visible through other means.
  ignore_result(receiver_->Accept(builder.message()));
}
class WindowTree_GetWindowTree_ProxyToResponder {
 public:
  static WindowTree::GetWindowTreeCallback CreateCallback(
      uint64_t request_id,
      bool is_sync,
      std::unique_ptr<mojo::MessageReceiverWithStatus> responder) {
    std::unique_ptr<WindowTree_GetWindowTree_ProxyToResponder> proxy(
        new WindowTree_GetWindowTree_ProxyToResponder(
            request_id, is_sync, std::move(responder)));
    return base::Bind(&WindowTree_GetWindowTree_ProxyToResponder::Run,
                      base::Passed(&proxy));
  }

  ~WindowTree_GetWindowTree_ProxyToResponder() {
#if DCHECK_IS_ON()
    if (responder_) {
      // Is the Service destroying the callback without running it
      // and without first closing the pipe?
      responder_->DCheckInvalid("The callback passed to "
          "WindowTree::GetWindowTree() was never run.");
    }
#endif
    // If the Callback was dropped then deleting the responder will close
    // the pipe so the calling application knows to stop waiting for a reply.
    responder_ = nullptr;
  }

 private:
  WindowTree_GetWindowTree_ProxyToResponder(
      uint64_t request_id,
      bool is_sync,
      std::unique_ptr<mojo::MessageReceiverWithStatus> responder)
      : request_id_(request_id),
        is_sync_(is_sync),
        responder_(std::move(responder)) {
  }

  void Run(
      WTF::Vector<::ui::mojom::blink::WindowDataPtr> in_windows);

  uint64_t request_id_;
  bool is_sync_;
  std::unique_ptr<mojo::MessageReceiverWithStatus> responder_;

  DISALLOW_COPY_AND_ASSIGN(WindowTree_GetWindowTree_ProxyToResponder);
};

void WindowTree_GetWindowTree_ProxyToResponder::Run(
    WTF::Vector<::ui::mojom::blink::WindowDataPtr> in_windows) {
  mojo::internal::SerializationContext serialization_context;
  size_t size = sizeof(::ui::mojom::internal::WindowTree_GetWindowTree_ResponseParams_Data);
  size += mojo::internal::PrepareToSerialize<mojo::ArrayDataView<::ui::mojom::WindowDataDataView>>(
      in_windows, &serialization_context);

  uint32_t flags = (is_sync_ ? mojo::Message::kFlagIsSync : 0) |
                   mojo::Message::kFlagIsResponse;
  mojo::internal::MessageBuilder builder(
      internal::kWindowTree_GetWindowTree_Name, flags, size,
      serialization_context.associated_endpoint_count);
  builder.message()->set_request_id(request_id_);

  auto params =
      ::ui::mojom::internal::WindowTree_GetWindowTree_ResponseParams_Data::New(builder.buffer());
  ALLOW_UNUSED_LOCAL(params);
  typename decltype(params->windows)::BaseType* windows_ptr;
  const mojo::internal::ContainerValidateParams windows_validate_params(
      0, false, nullptr);
  mojo::internal::Serialize<mojo::ArrayDataView<::ui::mojom::WindowDataDataView>>(
      in_windows, builder.buffer(), &windows_ptr, &windows_validate_params,
      &serialization_context);
  params->windows.Set(windows_ptr);
  MOJO_INTERNAL_DLOG_SERIALIZATION_WARNING(
      params->windows.is_null(),
      mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
      "null windows in WindowTree.GetWindowTree response");
  (&serialization_context)->handles.Swap(
      builder.message()->mutable_handles());
  (&serialization_context)->associated_endpoint_handles.swap(
      *builder.message()->mutable_associated_endpoint_handles());
  ignore_result(responder_->Accept(builder.message()));
  // TODO(darin): Accept() returning false indicates a malformed message, and
  // that may be good reason to close the connection. However, we don't have a
  // way to do that from here. We should add a way.
  responder_ = nullptr;
}
class WindowTree_Embed_ProxyToResponder {
 public:
  static WindowTree::EmbedCallback CreateCallback(
      uint64_t request_id,
      bool is_sync,
      std::unique_ptr<mojo::MessageReceiverWithStatus> responder) {
    std::unique_ptr<WindowTree_Embed_ProxyToResponder> proxy(
        new WindowTree_Embed_ProxyToResponder(
            request_id, is_sync, std::move(responder)));
    return base::Bind(&WindowTree_Embed_ProxyToResponder::Run,
                      base::Passed(&proxy));
  }

  ~WindowTree_Embed_ProxyToResponder() {
#if DCHECK_IS_ON()
    if (responder_) {
      // Is the Service destroying the callback without running it
      // and without first closing the pipe?
      responder_->DCheckInvalid("The callback passed to "
          "WindowTree::Embed() was never run.");
    }
#endif
    // If the Callback was dropped then deleting the responder will close
    // the pipe so the calling application knows to stop waiting for a reply.
    responder_ = nullptr;
  }

 private:
  WindowTree_Embed_ProxyToResponder(
      uint64_t request_id,
      bool is_sync,
      std::unique_ptr<mojo::MessageReceiverWithStatus> responder)
      : request_id_(request_id),
        is_sync_(is_sync),
        responder_(std::move(responder)) {
  }

  void Run(
      bool in_success);

  uint64_t request_id_;
  bool is_sync_;
  std::unique_ptr<mojo::MessageReceiverWithStatus> responder_;

  DISALLOW_COPY_AND_ASSIGN(WindowTree_Embed_ProxyToResponder);
};

void WindowTree_Embed_ProxyToResponder::Run(
    bool in_success) {
  mojo::internal::SerializationContext serialization_context;
  size_t size = sizeof(::ui::mojom::internal::WindowTree_Embed_ResponseParams_Data);

  uint32_t flags = (is_sync_ ? mojo::Message::kFlagIsSync : 0) |
                   mojo::Message::kFlagIsResponse;
  mojo::internal::MessageBuilder builder(
      internal::kWindowTree_Embed_Name, flags, size,
      serialization_context.associated_endpoint_count);
  builder.message()->set_request_id(request_id_);

  auto params =
      ::ui::mojom::internal::WindowTree_Embed_ResponseParams_Data::New(builder.buffer());
  ALLOW_UNUSED_LOCAL(params);
  params->success = in_success;
  (&serialization_context)->handles.Swap(
      builder.message()->mutable_handles());
  (&serialization_context)->associated_endpoint_handles.swap(
      *builder.message()->mutable_associated_endpoint_handles());
  ignore_result(responder_->Accept(builder.message()));
  // TODO(darin): Accept() returning false indicates a malformed message, and
  // that may be good reason to close the connection. However, we don't have a
  // way to do that from here. We should add a way.
  responder_ = nullptr;
}
class WindowTree_GetCursorLocationMemory_ProxyToResponder {
 public:
  static WindowTree::GetCursorLocationMemoryCallback CreateCallback(
      uint64_t request_id,
      bool is_sync,
      std::unique_ptr<mojo::MessageReceiverWithStatus> responder) {
    std::unique_ptr<WindowTree_GetCursorLocationMemory_ProxyToResponder> proxy(
        new WindowTree_GetCursorLocationMemory_ProxyToResponder(
            request_id, is_sync, std::move(responder)));
    return base::Bind(&WindowTree_GetCursorLocationMemory_ProxyToResponder::Run,
                      base::Passed(&proxy));
  }

  ~WindowTree_GetCursorLocationMemory_ProxyToResponder() {
#if DCHECK_IS_ON()
    if (responder_) {
      // Is the Service destroying the callback without running it
      // and without first closing the pipe?
      responder_->DCheckInvalid("The callback passed to "
          "WindowTree::GetCursorLocationMemory() was never run.");
    }
#endif
    // If the Callback was dropped then deleting the responder will close
    // the pipe so the calling application knows to stop waiting for a reply.
    responder_ = nullptr;
  }

 private:
  WindowTree_GetCursorLocationMemory_ProxyToResponder(
      uint64_t request_id,
      bool is_sync,
      std::unique_ptr<mojo::MessageReceiverWithStatus> responder)
      : request_id_(request_id),
        is_sync_(is_sync),
        responder_(std::move(responder)) {
  }

  void Run(
      mojo::ScopedSharedBufferHandle in_cursor_buffer);

  uint64_t request_id_;
  bool is_sync_;
  std::unique_ptr<mojo::MessageReceiverWithStatus> responder_;

  DISALLOW_COPY_AND_ASSIGN(WindowTree_GetCursorLocationMemory_ProxyToResponder);
};

void WindowTree_GetCursorLocationMemory_ProxyToResponder::Run(
    mojo::ScopedSharedBufferHandle in_cursor_buffer) {
  mojo::internal::SerializationContext serialization_context;
  size_t size = sizeof(::ui::mojom::internal::WindowTree_GetCursorLocationMemory_ResponseParams_Data);

  uint32_t flags = (is_sync_ ? mojo::Message::kFlagIsSync : 0) |
                   mojo::Message::kFlagIsResponse;
  mojo::internal::MessageBuilder builder(
      internal::kWindowTree_GetCursorLocationMemory_Name, flags, size,
      serialization_context.associated_endpoint_count);
  builder.message()->set_request_id(request_id_);

  auto params =
      ::ui::mojom::internal::WindowTree_GetCursorLocationMemory_ResponseParams_Data::New(builder.buffer());
  ALLOW_UNUSED_LOCAL(params);
  mojo::internal::Serialize<mojo::ScopedSharedBufferHandle>(
      in_cursor_buffer, &params->cursor_buffer, &serialization_context);
  MOJO_INTERNAL_DLOG_SERIALIZATION_WARNING(
      !mojo::internal::IsHandleOrInterfaceValid(params->cursor_buffer),
      mojo::internal::VALIDATION_ERROR_UNEXPECTED_INVALID_HANDLE,
      "invalid cursor_buffer in WindowTree.GetCursorLocationMemory response");
  (&serialization_context)->handles.Swap(
      builder.message()->mutable_handles());
  (&serialization_context)->associated_endpoint_handles.swap(
      *builder.message()->mutable_associated_endpoint_handles());
  ignore_result(responder_->Accept(builder.message()));
  // TODO(darin): Accept() returning false indicates a malformed message, and
  // that may be good reason to close the connection. However, we don't have a
  // way to do that from here. We should add a way.
  responder_ = nullptr;
}

// static
bool WindowTreeStubDispatch::Accept(
    WindowTree* impl,
    mojo::Message* message) {
  switch (message->header()->name) {
    case internal::kWindowTree_NewWindow_Name: {
      internal::WindowTree_NewWindow_Params_Data* params =
          reinterpret_cast<internal::WindowTree_NewWindow_Params_Data*>(
              message->mutable_payload());
      
      mojo::internal::SerializationContext serialization_context;
      serialization_context.handles.Swap((message)->mutable_handles());
      serialization_context.associated_endpoint_handles.swap(
          *(message)->mutable_associated_endpoint_handles());
      bool success = true;
      uint32_t p_change_id{};
      uint32_t p_window_id{};
      WTF::Optional<WTF::HashMap<WTF::String, WTF::Vector<uint8_t>>> p_properties{};
      WindowTree_NewWindow_ParamsDataView input_data_view(params, &serialization_context);
      
      p_change_id = input_data_view.change_id();
      p_window_id = input_data_view.window_id();
      if (!input_data_view.ReadProperties(&p_properties))
        success = false;
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            "WindowTree::NewWindow deserializer");
        return false;
      }
      // A null |impl| means no implementation was bound.
      assert(impl);
      TRACE_EVENT0("mojom", "WindowTree::NewWindow");
      mojo::internal::MessageDispatchContext context(message);
      impl->NewWindow(
std::move(p_change_id), 
std::move(p_window_id), 
std::move(p_properties));
      return true;
    }
    case internal::kWindowTree_NewTopLevelWindow_Name: {
      internal::WindowTree_NewTopLevelWindow_Params_Data* params =
          reinterpret_cast<internal::WindowTree_NewTopLevelWindow_Params_Data*>(
              message->mutable_payload());
      
      mojo::internal::SerializationContext serialization_context;
      serialization_context.handles.Swap((message)->mutable_handles());
      serialization_context.associated_endpoint_handles.swap(
          *(message)->mutable_associated_endpoint_handles());
      bool success = true;
      uint32_t p_change_id{};
      uint32_t p_window_id{};
      WTF::HashMap<WTF::String, WTF::Vector<uint8_t>> p_properties{};
      WindowTree_NewTopLevelWindow_ParamsDataView input_data_view(params, &serialization_context);
      
      p_change_id = input_data_view.change_id();
      p_window_id = input_data_view.window_id();
      if (!input_data_view.ReadProperties(&p_properties))
        success = false;
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            "WindowTree::NewTopLevelWindow deserializer");
        return false;
      }
      // A null |impl| means no implementation was bound.
      assert(impl);
      TRACE_EVENT0("mojom", "WindowTree::NewTopLevelWindow");
      mojo::internal::MessageDispatchContext context(message);
      impl->NewTopLevelWindow(
std::move(p_change_id), 
std::move(p_window_id), 
std::move(p_properties));
      return true;
    }
    case internal::kWindowTree_DeleteWindow_Name: {
      internal::WindowTree_DeleteWindow_Params_Data* params =
          reinterpret_cast<internal::WindowTree_DeleteWindow_Params_Data*>(
              message->mutable_payload());
      
      mojo::internal::SerializationContext serialization_context;
      serialization_context.handles.Swap((message)->mutable_handles());
      serialization_context.associated_endpoint_handles.swap(
          *(message)->mutable_associated_endpoint_handles());
      bool success = true;
      uint32_t p_change_id{};
      uint32_t p_window_id{};
      WindowTree_DeleteWindow_ParamsDataView input_data_view(params, &serialization_context);
      
      p_change_id = input_data_view.change_id();
      p_window_id = input_data_view.window_id();
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            "WindowTree::DeleteWindow deserializer");
        return false;
      }
      // A null |impl| means no implementation was bound.
      assert(impl);
      TRACE_EVENT0("mojom", "WindowTree::DeleteWindow");
      mojo::internal::MessageDispatchContext context(message);
      impl->DeleteWindow(
std::move(p_change_id), 
std::move(p_window_id));
      return true;
    }
    case internal::kWindowTree_SetCapture_Name: {
      internal::WindowTree_SetCapture_Params_Data* params =
          reinterpret_cast<internal::WindowTree_SetCapture_Params_Data*>(
              message->mutable_payload());
      
      mojo::internal::SerializationContext serialization_context;
      serialization_context.handles.Swap((message)->mutable_handles());
      serialization_context.associated_endpoint_handles.swap(
          *(message)->mutable_associated_endpoint_handles());
      bool success = true;
      uint32_t p_change_id{};
      uint32_t p_window_id{};
      WindowTree_SetCapture_ParamsDataView input_data_view(params, &serialization_context);
      
      p_change_id = input_data_view.change_id();
      p_window_id = input_data_view.window_id();
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            "WindowTree::SetCapture deserializer");
        return false;
      }
      // A null |impl| means no implementation was bound.
      assert(impl);
      TRACE_EVENT0("mojom", "WindowTree::SetCapture");
      mojo::internal::MessageDispatchContext context(message);
      impl->SetCapture(
std::move(p_change_id), 
std::move(p_window_id));
      return true;
    }
    case internal::kWindowTree_ReleaseCapture_Name: {
      internal::WindowTree_ReleaseCapture_Params_Data* params =
          reinterpret_cast<internal::WindowTree_ReleaseCapture_Params_Data*>(
              message->mutable_payload());
      
      mojo::internal::SerializationContext serialization_context;
      serialization_context.handles.Swap((message)->mutable_handles());
      serialization_context.associated_endpoint_handles.swap(
          *(message)->mutable_associated_endpoint_handles());
      bool success = true;
      uint32_t p_change_id{};
      uint32_t p_window_id{};
      WindowTree_ReleaseCapture_ParamsDataView input_data_view(params, &serialization_context);
      
      p_change_id = input_data_view.change_id();
      p_window_id = input_data_view.window_id();
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            "WindowTree::ReleaseCapture deserializer");
        return false;
      }
      // A null |impl| means no implementation was bound.
      assert(impl);
      TRACE_EVENT0("mojom", "WindowTree::ReleaseCapture");
      mojo::internal::MessageDispatchContext context(message);
      impl->ReleaseCapture(
std::move(p_change_id), 
std::move(p_window_id));
      return true;
    }
    case internal::kWindowTree_StartPointerWatcher_Name: {
      internal::WindowTree_StartPointerWatcher_Params_Data* params =
          reinterpret_cast<internal::WindowTree_StartPointerWatcher_Params_Data*>(
              message->mutable_payload());
      
      mojo::internal::SerializationContext serialization_context;
      serialization_context.handles.Swap((message)->mutable_handles());
      serialization_context.associated_endpoint_handles.swap(
          *(message)->mutable_associated_endpoint_handles());
      bool success = true;
      bool p_want_moves{};
      WindowTree_StartPointerWatcher_ParamsDataView input_data_view(params, &serialization_context);
      
      p_want_moves = input_data_view.want_moves();
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            "WindowTree::StartPointerWatcher deserializer");
        return false;
      }
      // A null |impl| means no implementation was bound.
      assert(impl);
      TRACE_EVENT0("mojom", "WindowTree::StartPointerWatcher");
      mojo::internal::MessageDispatchContext context(message);
      impl->StartPointerWatcher(
std::move(p_want_moves));
      return true;
    }
    case internal::kWindowTree_StopPointerWatcher_Name: {
      internal::WindowTree_StopPointerWatcher_Params_Data* params =
          reinterpret_cast<internal::WindowTree_StopPointerWatcher_Params_Data*>(
              message->mutable_payload());
      
      mojo::internal::SerializationContext serialization_context;
      serialization_context.handles.Swap((message)->mutable_handles());
      serialization_context.associated_endpoint_handles.swap(
          *(message)->mutable_associated_endpoint_handles());
      bool success = true;
      WindowTree_StopPointerWatcher_ParamsDataView input_data_view(params, &serialization_context);
      
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            "WindowTree::StopPointerWatcher deserializer");
        return false;
      }
      // A null |impl| means no implementation was bound.
      assert(impl);
      TRACE_EVENT0("mojom", "WindowTree::StopPointerWatcher");
      mojo::internal::MessageDispatchContext context(message);
      impl->StopPointerWatcher();
      return true;
    }
    case internal::kWindowTree_SetWindowBounds_Name: {
      internal::WindowTree_SetWindowBounds_Params_Data* params =
          reinterpret_cast<internal::WindowTree_SetWindowBounds_Params_Data*>(
              message->mutable_payload());
      
      mojo::internal::SerializationContext serialization_context;
      serialization_context.handles.Swap((message)->mutable_handles());
      serialization_context.associated_endpoint_handles.swap(
          *(message)->mutable_associated_endpoint_handles());
      bool success = true;
      uint32_t p_change_id{};
      uint32_t p_window_id{};
      ::gfx::mojom::blink::RectPtr p_bounds{};
      WTF::Optional<cc::LocalSurfaceId> p_local_surface_id{};
      WindowTree_SetWindowBounds_ParamsDataView input_data_view(params, &serialization_context);
      
      p_change_id = input_data_view.change_id();
      p_window_id = input_data_view.window_id();
      if (!input_data_view.ReadBounds(&p_bounds))
        success = false;
      if (!input_data_view.ReadLocalSurfaceId(&p_local_surface_id))
        success = false;
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            "WindowTree::SetWindowBounds deserializer");
        return false;
      }
      // A null |impl| means no implementation was bound.
      assert(impl);
      TRACE_EVENT0("mojom", "WindowTree::SetWindowBounds");
      mojo::internal::MessageDispatchContext context(message);
      impl->SetWindowBounds(
std::move(p_change_id), 
std::move(p_window_id), 
std::move(p_bounds), 
std::move(p_local_surface_id));
      return true;
    }
    case internal::kWindowTree_SetClientArea_Name: {
      internal::WindowTree_SetClientArea_Params_Data* params =
          reinterpret_cast<internal::WindowTree_SetClientArea_Params_Data*>(
              message->mutable_payload());
      
      mojo::internal::SerializationContext serialization_context;
      serialization_context.handles.Swap((message)->mutable_handles());
      serialization_context.associated_endpoint_handles.swap(
          *(message)->mutable_associated_endpoint_handles());
      bool success = true;
      uint32_t p_window_id{};
      ::gfx::mojom::blink::InsetsPtr p_insets{};
      WTF::Optional<WTF::Vector<::gfx::mojom::blink::RectPtr>> p_additional_client_areas{};
      WindowTree_SetClientArea_ParamsDataView input_data_view(params, &serialization_context);
      
      p_window_id = input_data_view.window_id();
      if (!input_data_view.ReadInsets(&p_insets))
        success = false;
      if (!input_data_view.ReadAdditionalClientAreas(&p_additional_client_areas))
        success = false;
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            "WindowTree::SetClientArea deserializer");
        return false;
      }
      // A null |impl| means no implementation was bound.
      assert(impl);
      TRACE_EVENT0("mojom", "WindowTree::SetClientArea");
      mojo::internal::MessageDispatchContext context(message);
      impl->SetClientArea(
std::move(p_window_id), 
std::move(p_insets), 
std::move(p_additional_client_areas));
      return true;
    }
    case internal::kWindowTree_SetHitTestMask_Name: {
      internal::WindowTree_SetHitTestMask_Params_Data* params =
          reinterpret_cast<internal::WindowTree_SetHitTestMask_Params_Data*>(
              message->mutable_payload());
      
      mojo::internal::SerializationContext serialization_context;
      serialization_context.handles.Swap((message)->mutable_handles());
      serialization_context.associated_endpoint_handles.swap(
          *(message)->mutable_associated_endpoint_handles());
      bool success = true;
      uint32_t p_window_id{};
      ::gfx::mojom::blink::RectPtr p_mask{};
      WindowTree_SetHitTestMask_ParamsDataView input_data_view(params, &serialization_context);
      
      p_window_id = input_data_view.window_id();
      if (!input_data_view.ReadMask(&p_mask))
        success = false;
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            "WindowTree::SetHitTestMask deserializer");
        return false;
      }
      // A null |impl| means no implementation was bound.
      assert(impl);
      TRACE_EVENT0("mojom", "WindowTree::SetHitTestMask");
      mojo::internal::MessageDispatchContext context(message);
      impl->SetHitTestMask(
std::move(p_window_id), 
std::move(p_mask));
      return true;
    }
    case internal::kWindowTree_SetCanAcceptDrops_Name: {
      internal::WindowTree_SetCanAcceptDrops_Params_Data* params =
          reinterpret_cast<internal::WindowTree_SetCanAcceptDrops_Params_Data*>(
              message->mutable_payload());
      
      mojo::internal::SerializationContext serialization_context;
      serialization_context.handles.Swap((message)->mutable_handles());
      serialization_context.associated_endpoint_handles.swap(
          *(message)->mutable_associated_endpoint_handles());
      bool success = true;
      uint32_t p_window_id{};
      bool p_accepts_drops{};
      WindowTree_SetCanAcceptDrops_ParamsDataView input_data_view(params, &serialization_context);
      
      p_window_id = input_data_view.window_id();
      p_accepts_drops = input_data_view.accepts_drops();
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            "WindowTree::SetCanAcceptDrops deserializer");
        return false;
      }
      // A null |impl| means no implementation was bound.
      assert(impl);
      TRACE_EVENT0("mojom", "WindowTree::SetCanAcceptDrops");
      mojo::internal::MessageDispatchContext context(message);
      impl->SetCanAcceptDrops(
std::move(p_window_id), 
std::move(p_accepts_drops));
      return true;
    }
    case internal::kWindowTree_SetWindowVisibility_Name: {
      internal::WindowTree_SetWindowVisibility_Params_Data* params =
          reinterpret_cast<internal::WindowTree_SetWindowVisibility_Params_Data*>(
              message->mutable_payload());
      
      mojo::internal::SerializationContext serialization_context;
      serialization_context.handles.Swap((message)->mutable_handles());
      serialization_context.associated_endpoint_handles.swap(
          *(message)->mutable_associated_endpoint_handles());
      bool success = true;
      uint32_t p_change_id{};
      uint32_t p_window_id{};
      bool p_visible{};
      WindowTree_SetWindowVisibility_ParamsDataView input_data_view(params, &serialization_context);
      
      p_change_id = input_data_view.change_id();
      p_window_id = input_data_view.window_id();
      p_visible = input_data_view.visible();
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            "WindowTree::SetWindowVisibility deserializer");
        return false;
      }
      // A null |impl| means no implementation was bound.
      assert(impl);
      TRACE_EVENT0("mojom", "WindowTree::SetWindowVisibility");
      mojo::internal::MessageDispatchContext context(message);
      impl->SetWindowVisibility(
std::move(p_change_id), 
std::move(p_window_id), 
std::move(p_visible));
      return true;
    }
    case internal::kWindowTree_SetWindowProperty_Name: {
      internal::WindowTree_SetWindowProperty_Params_Data* params =
          reinterpret_cast<internal::WindowTree_SetWindowProperty_Params_Data*>(
              message->mutable_payload());
      
      mojo::internal::SerializationContext serialization_context;
      serialization_context.handles.Swap((message)->mutable_handles());
      serialization_context.associated_endpoint_handles.swap(
          *(message)->mutable_associated_endpoint_handles());
      bool success = true;
      uint32_t p_change_id{};
      uint32_t p_window_id{};
      WTF::String p_name{};
      WTF::Optional<WTF::Vector<uint8_t>> p_value{};
      WindowTree_SetWindowProperty_ParamsDataView input_data_view(params, &serialization_context);
      
      p_change_id = input_data_view.change_id();
      p_window_id = input_data_view.window_id();
      if (!input_data_view.ReadName(&p_name))
        success = false;
      if (!input_data_view.ReadValue(&p_value))
        success = false;
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            "WindowTree::SetWindowProperty deserializer");
        return false;
      }
      // A null |impl| means no implementation was bound.
      assert(impl);
      TRACE_EVENT0("mojom", "WindowTree::SetWindowProperty");
      mojo::internal::MessageDispatchContext context(message);
      impl->SetWindowProperty(
std::move(p_change_id), 
std::move(p_window_id), 
std::move(p_name), 
std::move(p_value));
      return true;
    }
    case internal::kWindowTree_SetWindowOpacity_Name: {
      internal::WindowTree_SetWindowOpacity_Params_Data* params =
          reinterpret_cast<internal::WindowTree_SetWindowOpacity_Params_Data*>(
              message->mutable_payload());
      
      mojo::internal::SerializationContext serialization_context;
      serialization_context.handles.Swap((message)->mutable_handles());
      serialization_context.associated_endpoint_handles.swap(
          *(message)->mutable_associated_endpoint_handles());
      bool success = true;
      uint32_t p_change_id{};
      uint32_t p_window_id{};
      float p_opacity{};
      WindowTree_SetWindowOpacity_ParamsDataView input_data_view(params, &serialization_context);
      
      p_change_id = input_data_view.change_id();
      p_window_id = input_data_view.window_id();
      p_opacity = input_data_view.opacity();
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            "WindowTree::SetWindowOpacity deserializer");
        return false;
      }
      // A null |impl| means no implementation was bound.
      assert(impl);
      TRACE_EVENT0("mojom", "WindowTree::SetWindowOpacity");
      mojo::internal::MessageDispatchContext context(message);
      impl->SetWindowOpacity(
std::move(p_change_id), 
std::move(p_window_id), 
std::move(p_opacity));
      return true;
    }
    case internal::kWindowTree_AttachCompositorFrameSink_Name: {
      internal::WindowTree_AttachCompositorFrameSink_Params_Data* params =
          reinterpret_cast<internal::WindowTree_AttachCompositorFrameSink_Params_Data*>(
              message->mutable_payload());
      
      mojo::internal::SerializationContext serialization_context;
      serialization_context.handles.Swap((message)->mutable_handles());
      serialization_context.associated_endpoint_handles.swap(
          *(message)->mutable_associated_endpoint_handles());
      bool success = true;
      uint32_t p_window_id{};
      ::cc::mojom::blink::MojoCompositorFrameSinkRequest p_compositor_frame_sink{};
      ::cc::mojom::blink::MojoCompositorFrameSinkClientPtr p_client{};
      WindowTree_AttachCompositorFrameSink_ParamsDataView input_data_view(params, &serialization_context);
      
      p_window_id = input_data_view.window_id();
      p_compositor_frame_sink =
          input_data_view.TakeCompositorFrameSink<decltype(p_compositor_frame_sink)>();
      p_client =
          input_data_view.TakeClient<decltype(p_client)>();
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            "WindowTree::AttachCompositorFrameSink deserializer");
        return false;
      }
      // A null |impl| means no implementation was bound.
      assert(impl);
      TRACE_EVENT0("mojom", "WindowTree::AttachCompositorFrameSink");
      mojo::internal::MessageDispatchContext context(message);
      impl->AttachCompositorFrameSink(
std::move(p_window_id), 
std::move(p_compositor_frame_sink), 
std::move(p_client));
      return true;
    }
    case internal::kWindowTree_AddWindow_Name: {
      internal::WindowTree_AddWindow_Params_Data* params =
          reinterpret_cast<internal::WindowTree_AddWindow_Params_Data*>(
              message->mutable_payload());
      
      mojo::internal::SerializationContext serialization_context;
      serialization_context.handles.Swap((message)->mutable_handles());
      serialization_context.associated_endpoint_handles.swap(
          *(message)->mutable_associated_endpoint_handles());
      bool success = true;
      uint32_t p_change_id{};
      uint32_t p_parent{};
      uint32_t p_child{};
      WindowTree_AddWindow_ParamsDataView input_data_view(params, &serialization_context);
      
      p_change_id = input_data_view.change_id();
      p_parent = input_data_view.parent();
      p_child = input_data_view.child();
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            "WindowTree::AddWindow deserializer");
        return false;
      }
      // A null |impl| means no implementation was bound.
      assert(impl);
      TRACE_EVENT0("mojom", "WindowTree::AddWindow");
      mojo::internal::MessageDispatchContext context(message);
      impl->AddWindow(
std::move(p_change_id), 
std::move(p_parent), 
std::move(p_child));
      return true;
    }
    case internal::kWindowTree_RemoveWindowFromParent_Name: {
      internal::WindowTree_RemoveWindowFromParent_Params_Data* params =
          reinterpret_cast<internal::WindowTree_RemoveWindowFromParent_Params_Data*>(
              message->mutable_payload());
      
      mojo::internal::SerializationContext serialization_context;
      serialization_context.handles.Swap((message)->mutable_handles());
      serialization_context.associated_endpoint_handles.swap(
          *(message)->mutable_associated_endpoint_handles());
      bool success = true;
      uint32_t p_change_id{};
      uint32_t p_window_id{};
      WindowTree_RemoveWindowFromParent_ParamsDataView input_data_view(params, &serialization_context);
      
      p_change_id = input_data_view.change_id();
      p_window_id = input_data_view.window_id();
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            "WindowTree::RemoveWindowFromParent deserializer");
        return false;
      }
      // A null |impl| means no implementation was bound.
      assert(impl);
      TRACE_EVENT0("mojom", "WindowTree::RemoveWindowFromParent");
      mojo::internal::MessageDispatchContext context(message);
      impl->RemoveWindowFromParent(
std::move(p_change_id), 
std::move(p_window_id));
      return true;
    }
    case internal::kWindowTree_AddTransientWindow_Name: {
      internal::WindowTree_AddTransientWindow_Params_Data* params =
          reinterpret_cast<internal::WindowTree_AddTransientWindow_Params_Data*>(
              message->mutable_payload());
      
      mojo::internal::SerializationContext serialization_context;
      serialization_context.handles.Swap((message)->mutable_handles());
      serialization_context.associated_endpoint_handles.swap(
          *(message)->mutable_associated_endpoint_handles());
      bool success = true;
      uint32_t p_change_id{};
      uint32_t p_window_id{};
      uint32_t p_transient_window_id{};
      WindowTree_AddTransientWindow_ParamsDataView input_data_view(params, &serialization_context);
      
      p_change_id = input_data_view.change_id();
      p_window_id = input_data_view.window_id();
      p_transient_window_id = input_data_view.transient_window_id();
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            "WindowTree::AddTransientWindow deserializer");
        return false;
      }
      // A null |impl| means no implementation was bound.
      assert(impl);
      TRACE_EVENT0("mojom", "WindowTree::AddTransientWindow");
      mojo::internal::MessageDispatchContext context(message);
      impl->AddTransientWindow(
std::move(p_change_id), 
std::move(p_window_id), 
std::move(p_transient_window_id));
      return true;
    }
    case internal::kWindowTree_RemoveTransientWindowFromParent_Name: {
      internal::WindowTree_RemoveTransientWindowFromParent_Params_Data* params =
          reinterpret_cast<internal::WindowTree_RemoveTransientWindowFromParent_Params_Data*>(
              message->mutable_payload());
      
      mojo::internal::SerializationContext serialization_context;
      serialization_context.handles.Swap((message)->mutable_handles());
      serialization_context.associated_endpoint_handles.swap(
          *(message)->mutable_associated_endpoint_handles());
      bool success = true;
      uint32_t p_change_id{};
      uint32_t p_transient_window_id{};
      WindowTree_RemoveTransientWindowFromParent_ParamsDataView input_data_view(params, &serialization_context);
      
      p_change_id = input_data_view.change_id();
      p_transient_window_id = input_data_view.transient_window_id();
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            "WindowTree::RemoveTransientWindowFromParent deserializer");
        return false;
      }
      // A null |impl| means no implementation was bound.
      assert(impl);
      TRACE_EVENT0("mojom", "WindowTree::RemoveTransientWindowFromParent");
      mojo::internal::MessageDispatchContext context(message);
      impl->RemoveTransientWindowFromParent(
std::move(p_change_id), 
std::move(p_transient_window_id));
      return true;
    }
    case internal::kWindowTree_SetModalType_Name: {
      internal::WindowTree_SetModalType_Params_Data* params =
          reinterpret_cast<internal::WindowTree_SetModalType_Params_Data*>(
              message->mutable_payload());
      
      mojo::internal::SerializationContext serialization_context;
      serialization_context.handles.Swap((message)->mutable_handles());
      serialization_context.associated_endpoint_handles.swap(
          *(message)->mutable_associated_endpoint_handles());
      bool success = true;
      uint32_t p_change_id{};
      uint32_t p_window_id{};
      ::ui::mojom::blink::ModalType p_type{};
      WindowTree_SetModalType_ParamsDataView input_data_view(params, &serialization_context);
      
      p_change_id = input_data_view.change_id();
      p_window_id = input_data_view.window_id();
      if (!input_data_view.ReadType(&p_type))
        success = false;
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            "WindowTree::SetModalType deserializer");
        return false;
      }
      // A null |impl| means no implementation was bound.
      assert(impl);
      TRACE_EVENT0("mojom", "WindowTree::SetModalType");
      mojo::internal::MessageDispatchContext context(message);
      impl->SetModalType(
std::move(p_change_id), 
std::move(p_window_id), 
std::move(p_type));
      return true;
    }
    case internal::kWindowTree_ReorderWindow_Name: {
      internal::WindowTree_ReorderWindow_Params_Data* params =
          reinterpret_cast<internal::WindowTree_ReorderWindow_Params_Data*>(
              message->mutable_payload());
      
      mojo::internal::SerializationContext serialization_context;
      serialization_context.handles.Swap((message)->mutable_handles());
      serialization_context.associated_endpoint_handles.swap(
          *(message)->mutable_associated_endpoint_handles());
      bool success = true;
      uint32_t p_change_id{};
      uint32_t p_window_id{};
      uint32_t p_relative_window_id{};
      ::ui::mojom::blink::OrderDirection p_direction{};
      WindowTree_ReorderWindow_ParamsDataView input_data_view(params, &serialization_context);
      
      p_change_id = input_data_view.change_id();
      p_window_id = input_data_view.window_id();
      p_relative_window_id = input_data_view.relative_window_id();
      if (!input_data_view.ReadDirection(&p_direction))
        success = false;
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            "WindowTree::ReorderWindow deserializer");
        return false;
      }
      // A null |impl| means no implementation was bound.
      assert(impl);
      TRACE_EVENT0("mojom", "WindowTree::ReorderWindow");
      mojo::internal::MessageDispatchContext context(message);
      impl->ReorderWindow(
std::move(p_change_id), 
std::move(p_window_id), 
std::move(p_relative_window_id), 
std::move(p_direction));
      return true;
    }
    case internal::kWindowTree_GetWindowTree_Name: {
      break;
    }
    case internal::kWindowTree_Embed_Name: {
      break;
    }
    case internal::kWindowTree_SetFocus_Name: {
      internal::WindowTree_SetFocus_Params_Data* params =
          reinterpret_cast<internal::WindowTree_SetFocus_Params_Data*>(
              message->mutable_payload());
      
      mojo::internal::SerializationContext serialization_context;
      serialization_context.handles.Swap((message)->mutable_handles());
      serialization_context.associated_endpoint_handles.swap(
          *(message)->mutable_associated_endpoint_handles());
      bool success = true;
      uint32_t p_change_id{};
      uint32_t p_window_id{};
      WindowTree_SetFocus_ParamsDataView input_data_view(params, &serialization_context);
      
      p_change_id = input_data_view.change_id();
      p_window_id = input_data_view.window_id();
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            "WindowTree::SetFocus deserializer");
        return false;
      }
      // A null |impl| means no implementation was bound.
      assert(impl);
      TRACE_EVENT0("mojom", "WindowTree::SetFocus");
      mojo::internal::MessageDispatchContext context(message);
      impl->SetFocus(
std::move(p_change_id), 
std::move(p_window_id));
      return true;
    }
    case internal::kWindowTree_SetCanFocus_Name: {
      internal::WindowTree_SetCanFocus_Params_Data* params =
          reinterpret_cast<internal::WindowTree_SetCanFocus_Params_Data*>(
              message->mutable_payload());
      
      mojo::internal::SerializationContext serialization_context;
      serialization_context.handles.Swap((message)->mutable_handles());
      serialization_context.associated_endpoint_handles.swap(
          *(message)->mutable_associated_endpoint_handles());
      bool success = true;
      uint32_t p_window_id{};
      bool p_can_focus{};
      WindowTree_SetCanFocus_ParamsDataView input_data_view(params, &serialization_context);
      
      p_window_id = input_data_view.window_id();
      p_can_focus = input_data_view.can_focus();
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            "WindowTree::SetCanFocus deserializer");
        return false;
      }
      // A null |impl| means no implementation was bound.
      assert(impl);
      TRACE_EVENT0("mojom", "WindowTree::SetCanFocus");
      mojo::internal::MessageDispatchContext context(message);
      impl->SetCanFocus(
std::move(p_window_id), 
std::move(p_can_focus));
      return true;
    }
    case internal::kWindowTree_SetCursor_Name: {
      internal::WindowTree_SetCursor_Params_Data* params =
          reinterpret_cast<internal::WindowTree_SetCursor_Params_Data*>(
              message->mutable_payload());
      
      mojo::internal::SerializationContext serialization_context;
      serialization_context.handles.Swap((message)->mutable_handles());
      serialization_context.associated_endpoint_handles.swap(
          *(message)->mutable_associated_endpoint_handles());
      bool success = true;
      uint32_t p_change_id{};
      uint32_t p_window_id{};
      ::ui::mojom::blink::CursorDataPtr p_cursor{};
      WindowTree_SetCursor_ParamsDataView input_data_view(params, &serialization_context);
      
      p_change_id = input_data_view.change_id();
      p_window_id = input_data_view.window_id();
      if (!input_data_view.ReadCursor(&p_cursor))
        success = false;
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            "WindowTree::SetCursor deserializer");
        return false;
      }
      // A null |impl| means no implementation was bound.
      assert(impl);
      TRACE_EVENT0("mojom", "WindowTree::SetCursor");
      mojo::internal::MessageDispatchContext context(message);
      impl->SetCursor(
std::move(p_change_id), 
std::move(p_window_id), 
std::move(p_cursor));
      return true;
    }
    case internal::kWindowTree_SetWindowTextInputState_Name: {
      internal::WindowTree_SetWindowTextInputState_Params_Data* params =
          reinterpret_cast<internal::WindowTree_SetWindowTextInputState_Params_Data*>(
              message->mutable_payload());
      
      mojo::internal::SerializationContext serialization_context;
      serialization_context.handles.Swap((message)->mutable_handles());
      serialization_context.associated_endpoint_handles.swap(
          *(message)->mutable_associated_endpoint_handles());
      bool success = true;
      uint32_t p_window_id{};
      ::mojo::blink::TextInputStatePtr p_state{};
      WindowTree_SetWindowTextInputState_ParamsDataView input_data_view(params, &serialization_context);
      
      p_window_id = input_data_view.window_id();
      if (!input_data_view.ReadState(&p_state))
        success = false;
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            "WindowTree::SetWindowTextInputState deserializer");
        return false;
      }
      // A null |impl| means no implementation was bound.
      assert(impl);
      TRACE_EVENT0("mojom", "WindowTree::SetWindowTextInputState");
      mojo::internal::MessageDispatchContext context(message);
      impl->SetWindowTextInputState(
std::move(p_window_id), 
std::move(p_state));
      return true;
    }
    case internal::kWindowTree_SetImeVisibility_Name: {
      internal::WindowTree_SetImeVisibility_Params_Data* params =
          reinterpret_cast<internal::WindowTree_SetImeVisibility_Params_Data*>(
              message->mutable_payload());
      
      mojo::internal::SerializationContext serialization_context;
      serialization_context.handles.Swap((message)->mutable_handles());
      serialization_context.associated_endpoint_handles.swap(
          *(message)->mutable_associated_endpoint_handles());
      bool success = true;
      uint32_t p_window_id{};
      bool p_visible{};
      ::mojo::blink::TextInputStatePtr p_state{};
      WindowTree_SetImeVisibility_ParamsDataView input_data_view(params, &serialization_context);
      
      p_window_id = input_data_view.window_id();
      p_visible = input_data_view.visible();
      if (!input_data_view.ReadState(&p_state))
        success = false;
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            "WindowTree::SetImeVisibility deserializer");
        return false;
      }
      // A null |impl| means no implementation was bound.
      assert(impl);
      TRACE_EVENT0("mojom", "WindowTree::SetImeVisibility");
      mojo::internal::MessageDispatchContext context(message);
      impl->SetImeVisibility(
std::move(p_window_id), 
std::move(p_visible), 
std::move(p_state));
      return true;
    }
    case internal::kWindowTree_SetEventTargetingPolicy_Name: {
      internal::WindowTree_SetEventTargetingPolicy_Params_Data* params =
          reinterpret_cast<internal::WindowTree_SetEventTargetingPolicy_Params_Data*>(
              message->mutable_payload());
      
      mojo::internal::SerializationContext serialization_context;
      serialization_context.handles.Swap((message)->mutable_handles());
      serialization_context.associated_endpoint_handles.swap(
          *(message)->mutable_associated_endpoint_handles());
      bool success = true;
      uint32_t p_window_id{};
      ::ui::mojom::blink::EventTargetingPolicy p_policy{};
      WindowTree_SetEventTargetingPolicy_ParamsDataView input_data_view(params, &serialization_context);
      
      p_window_id = input_data_view.window_id();
      if (!input_data_view.ReadPolicy(&p_policy))
        success = false;
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            "WindowTree::SetEventTargetingPolicy deserializer");
        return false;
      }
      // A null |impl| means no implementation was bound.
      assert(impl);
      TRACE_EVENT0("mojom", "WindowTree::SetEventTargetingPolicy");
      mojo::internal::MessageDispatchContext context(message);
      impl->SetEventTargetingPolicy(
std::move(p_window_id), 
std::move(p_policy));
      return true;
    }
    case internal::kWindowTree_OnWindowInputEventAck_Name: {
      internal::WindowTree_OnWindowInputEventAck_Params_Data* params =
          reinterpret_cast<internal::WindowTree_OnWindowInputEventAck_Params_Data*>(
              message->mutable_payload());
      
      mojo::internal::SerializationContext serialization_context;
      serialization_context.handles.Swap((message)->mutable_handles());
      serialization_context.associated_endpoint_handles.swap(
          *(message)->mutable_associated_endpoint_handles());
      bool success = true;
      uint32_t p_event_id{};
      ::ui::mojom::blink::EventResult p_result{};
      WindowTree_OnWindowInputEventAck_ParamsDataView input_data_view(params, &serialization_context);
      
      p_event_id = input_data_view.event_id();
      if (!input_data_view.ReadResult(&p_result))
        success = false;
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            "WindowTree::OnWindowInputEventAck deserializer");
        return false;
      }
      // A null |impl| means no implementation was bound.
      assert(impl);
      TRACE_EVENT0("mojom", "WindowTree::OnWindowInputEventAck");
      mojo::internal::MessageDispatchContext context(message);
      impl->OnWindowInputEventAck(
std::move(p_event_id), 
std::move(p_result));
      return true;
    }
    case internal::kWindowTree_DeactivateWindow_Name: {
      internal::WindowTree_DeactivateWindow_Params_Data* params =
          reinterpret_cast<internal::WindowTree_DeactivateWindow_Params_Data*>(
              message->mutable_payload());
      
      mojo::internal::SerializationContext serialization_context;
      serialization_context.handles.Swap((message)->mutable_handles());
      serialization_context.associated_endpoint_handles.swap(
          *(message)->mutable_associated_endpoint_handles());
      bool success = true;
      uint32_t p_window_id{};
      WindowTree_DeactivateWindow_ParamsDataView input_data_view(params, &serialization_context);
      
      p_window_id = input_data_view.window_id();
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            "WindowTree::DeactivateWindow deserializer");
        return false;
      }
      // A null |impl| means no implementation was bound.
      assert(impl);
      TRACE_EVENT0("mojom", "WindowTree::DeactivateWindow");
      mojo::internal::MessageDispatchContext context(message);
      impl->DeactivateWindow(
std::move(p_window_id));
      return true;
    }
    case internal::kWindowTree_StackAbove_Name: {
      internal::WindowTree_StackAbove_Params_Data* params =
          reinterpret_cast<internal::WindowTree_StackAbove_Params_Data*>(
              message->mutable_payload());
      
      mojo::internal::SerializationContext serialization_context;
      serialization_context.handles.Swap((message)->mutable_handles());
      serialization_context.associated_endpoint_handles.swap(
          *(message)->mutable_associated_endpoint_handles());
      bool success = true;
      uint32_t p_change_id{};
      uint32_t p_above_id{};
      uint32_t p_below_id{};
      WindowTree_StackAbove_ParamsDataView input_data_view(params, &serialization_context);
      
      p_change_id = input_data_view.change_id();
      p_above_id = input_data_view.above_id();
      p_below_id = input_data_view.below_id();
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            "WindowTree::StackAbove deserializer");
        return false;
      }
      // A null |impl| means no implementation was bound.
      assert(impl);
      TRACE_EVENT0("mojom", "WindowTree::StackAbove");
      mojo::internal::MessageDispatchContext context(message);
      impl->StackAbove(
std::move(p_change_id), 
std::move(p_above_id), 
std::move(p_below_id));
      return true;
    }
    case internal::kWindowTree_StackAtTop_Name: {
      internal::WindowTree_StackAtTop_Params_Data* params =
          reinterpret_cast<internal::WindowTree_StackAtTop_Params_Data*>(
              message->mutable_payload());
      
      mojo::internal::SerializationContext serialization_context;
      serialization_context.handles.Swap((message)->mutable_handles());
      serialization_context.associated_endpoint_handles.swap(
          *(message)->mutable_associated_endpoint_handles());
      bool success = true;
      uint32_t p_change_id{};
      uint32_t p_window_id{};
      WindowTree_StackAtTop_ParamsDataView input_data_view(params, &serialization_context);
      
      p_change_id = input_data_view.change_id();
      p_window_id = input_data_view.window_id();
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            "WindowTree::StackAtTop deserializer");
        return false;
      }
      // A null |impl| means no implementation was bound.
      assert(impl);
      TRACE_EVENT0("mojom", "WindowTree::StackAtTop");
      mojo::internal::MessageDispatchContext context(message);
      impl->StackAtTop(
std::move(p_change_id), 
std::move(p_window_id));
      return true;
    }
    case internal::kWindowTree_GetWindowManagerClient_Name: {
      internal::WindowTree_GetWindowManagerClient_Params_Data* params =
          reinterpret_cast<internal::WindowTree_GetWindowManagerClient_Params_Data*>(
              message->mutable_payload());
      
      mojo::internal::SerializationContext serialization_context;
      serialization_context.handles.Swap((message)->mutable_handles());
      serialization_context.associated_endpoint_handles.swap(
          *(message)->mutable_associated_endpoint_handles());
      bool success = true;
      ::ui::mojom::blink::WindowManagerClientAssociatedRequest p_internal{};
      WindowTree_GetWindowManagerClient_ParamsDataView input_data_view(params, &serialization_context);
      
      p_internal =
          input_data_view.TakeInternal<decltype(p_internal)>();
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            "WindowTree::GetWindowManagerClient deserializer");
        return false;
      }
      // A null |impl| means no implementation was bound.
      assert(impl);
      TRACE_EVENT0("mojom", "WindowTree::GetWindowManagerClient");
      mojo::internal::MessageDispatchContext context(message);
      impl->GetWindowManagerClient(
std::move(p_internal));
      return true;
    }
    case internal::kWindowTree_GetCursorLocationMemory_Name: {
      break;
    }
    case internal::kWindowTree_PerformWindowMove_Name: {
      internal::WindowTree_PerformWindowMove_Params_Data* params =
          reinterpret_cast<internal::WindowTree_PerformWindowMove_Params_Data*>(
              message->mutable_payload());
      
      mojo::internal::SerializationContext serialization_context;
      serialization_context.handles.Swap((message)->mutable_handles());
      serialization_context.associated_endpoint_handles.swap(
          *(message)->mutable_associated_endpoint_handles());
      bool success = true;
      uint32_t p_change_id{};
      uint32_t p_window_id{};
      ::ui::mojom::blink::MoveLoopSource p_source{};
      ::gfx::mojom::blink::PointPtr p_cursor{};
      WindowTree_PerformWindowMove_ParamsDataView input_data_view(params, &serialization_context);
      
      p_change_id = input_data_view.change_id();
      p_window_id = input_data_view.window_id();
      if (!input_data_view.ReadSource(&p_source))
        success = false;
      if (!input_data_view.ReadCursor(&p_cursor))
        success = false;
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            "WindowTree::PerformWindowMove deserializer");
        return false;
      }
      // A null |impl| means no implementation was bound.
      assert(impl);
      TRACE_EVENT0("mojom", "WindowTree::PerformWindowMove");
      mojo::internal::MessageDispatchContext context(message);
      impl->PerformWindowMove(
std::move(p_change_id), 
std::move(p_window_id), 
std::move(p_source), 
std::move(p_cursor));
      return true;
    }
    case internal::kWindowTree_CancelWindowMove_Name: {
      internal::WindowTree_CancelWindowMove_Params_Data* params =
          reinterpret_cast<internal::WindowTree_CancelWindowMove_Params_Data*>(
              message->mutable_payload());
      
      mojo::internal::SerializationContext serialization_context;
      serialization_context.handles.Swap((message)->mutable_handles());
      serialization_context.associated_endpoint_handles.swap(
          *(message)->mutable_associated_endpoint_handles());
      bool success = true;
      uint32_t p_window_id{};
      WindowTree_CancelWindowMove_ParamsDataView input_data_view(params, &serialization_context);
      
      p_window_id = input_data_view.window_id();
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            "WindowTree::CancelWindowMove deserializer");
        return false;
      }
      // A null |impl| means no implementation was bound.
      assert(impl);
      TRACE_EVENT0("mojom", "WindowTree::CancelWindowMove");
      mojo::internal::MessageDispatchContext context(message);
      impl->CancelWindowMove(
std::move(p_window_id));
      return true;
    }
    case internal::kWindowTree_PerformDragDrop_Name: {
      internal::WindowTree_PerformDragDrop_Params_Data* params =
          reinterpret_cast<internal::WindowTree_PerformDragDrop_Params_Data*>(
              message->mutable_payload());
      
      mojo::internal::SerializationContext serialization_context;
      serialization_context.handles.Swap((message)->mutable_handles());
      serialization_context.associated_endpoint_handles.swap(
          *(message)->mutable_associated_endpoint_handles());
      bool success = true;
      uint32_t p_change_id{};
      uint32_t p_source_window_id{};
      ::gfx::mojom::blink::PointPtr p_screen_location{};
      WTF::HashMap<WTF::String, WTF::Vector<uint8_t>> p_drag_data{};
      ::skia::mojom::blink::BitmapPtr p_drag_image{};
      ::gfx::mojom::blink::Vector2dPtr p_drag_image_offset{};
      uint32_t p_drag_operation{};
      ::ui::mojom::blink::PointerKind p_source{};
      WindowTree_PerformDragDrop_ParamsDataView input_data_view(params, &serialization_context);
      
      p_change_id = input_data_view.change_id();
      p_source_window_id = input_data_view.source_window_id();
      if (!input_data_view.ReadScreenLocation(&p_screen_location))
        success = false;
      if (!input_data_view.ReadDragData(&p_drag_data))
        success = false;
      if (!input_data_view.ReadDragImage(&p_drag_image))
        success = false;
      if (!input_data_view.ReadDragImageOffset(&p_drag_image_offset))
        success = false;
      p_drag_operation = input_data_view.drag_operation();
      if (!input_data_view.ReadSource(&p_source))
        success = false;
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            "WindowTree::PerformDragDrop deserializer");
        return false;
      }
      // A null |impl| means no implementation was bound.
      assert(impl);
      TRACE_EVENT0("mojom", "WindowTree::PerformDragDrop");
      mojo::internal::MessageDispatchContext context(message);
      impl->PerformDragDrop(
std::move(p_change_id), 
std::move(p_source_window_id), 
std::move(p_screen_location), 
std::move(p_drag_data), 
std::move(p_drag_image), 
std::move(p_drag_image_offset), 
std::move(p_drag_operation), 
std::move(p_source));
      return true;
    }
    case internal::kWindowTree_CancelDragDrop_Name: {
      internal::WindowTree_CancelDragDrop_Params_Data* params =
          reinterpret_cast<internal::WindowTree_CancelDragDrop_Params_Data*>(
              message->mutable_payload());
      
      mojo::internal::SerializationContext serialization_context;
      serialization_context.handles.Swap((message)->mutable_handles());
      serialization_context.associated_endpoint_handles.swap(
          *(message)->mutable_associated_endpoint_handles());
      bool success = true;
      uint32_t p_window_id{};
      WindowTree_CancelDragDrop_ParamsDataView input_data_view(params, &serialization_context);
      
      p_window_id = input_data_view.window_id();
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            "WindowTree::CancelDragDrop deserializer");
        return false;
      }
      // A null |impl| means no implementation was bound.
      assert(impl);
      TRACE_EVENT0("mojom", "WindowTree::CancelDragDrop");
      mojo::internal::MessageDispatchContext context(message);
      impl->CancelDragDrop(
std::move(p_window_id));
      return true;
    }
  }
  return false;
}

// static
bool WindowTreeStubDispatch::AcceptWithResponder(
    WindowTree* impl,
    mojo::Message* message,
    std::unique_ptr<mojo::MessageReceiverWithStatus> responder) {
  switch (message->header()->name) {
    case internal::kWindowTree_NewWindow_Name: {
      break;
    }
    case internal::kWindowTree_NewTopLevelWindow_Name: {
      break;
    }
    case internal::kWindowTree_DeleteWindow_Name: {
      break;
    }
    case internal::kWindowTree_SetCapture_Name: {
      break;
    }
    case internal::kWindowTree_ReleaseCapture_Name: {
      break;
    }
    case internal::kWindowTree_StartPointerWatcher_Name: {
      break;
    }
    case internal::kWindowTree_StopPointerWatcher_Name: {
      break;
    }
    case internal::kWindowTree_SetWindowBounds_Name: {
      break;
    }
    case internal::kWindowTree_SetClientArea_Name: {
      break;
    }
    case internal::kWindowTree_SetHitTestMask_Name: {
      break;
    }
    case internal::kWindowTree_SetCanAcceptDrops_Name: {
      break;
    }
    case internal::kWindowTree_SetWindowVisibility_Name: {
      break;
    }
    case internal::kWindowTree_SetWindowProperty_Name: {
      break;
    }
    case internal::kWindowTree_SetWindowOpacity_Name: {
      break;
    }
    case internal::kWindowTree_AttachCompositorFrameSink_Name: {
      break;
    }
    case internal::kWindowTree_AddWindow_Name: {
      break;
    }
    case internal::kWindowTree_RemoveWindowFromParent_Name: {
      break;
    }
    case internal::kWindowTree_AddTransientWindow_Name: {
      break;
    }
    case internal::kWindowTree_RemoveTransientWindowFromParent_Name: {
      break;
    }
    case internal::kWindowTree_SetModalType_Name: {
      break;
    }
    case internal::kWindowTree_ReorderWindow_Name: {
      break;
    }
    case internal::kWindowTree_GetWindowTree_Name: {
      internal::WindowTree_GetWindowTree_Params_Data* params =
          reinterpret_cast<internal::WindowTree_GetWindowTree_Params_Data*>(
              message->mutable_payload());
      
      mojo::internal::SerializationContext serialization_context;
      serialization_context.handles.Swap((message)->mutable_handles());
      serialization_context.associated_endpoint_handles.swap(
          *(message)->mutable_associated_endpoint_handles());
      bool success = true;
      uint32_t p_window_id{};
      WindowTree_GetWindowTree_ParamsDataView input_data_view(params, &serialization_context);
      
      p_window_id = input_data_view.window_id();
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            "WindowTree::GetWindowTree deserializer");
        return false;
      }
      WindowTree::GetWindowTreeCallback callback =
          WindowTree_GetWindowTree_ProxyToResponder::CreateCallback(
              message->request_id(),
              message->has_flag(mojo::Message::kFlagIsSync),
              std::move(responder));
      // A null |impl| means no implementation was bound.
      assert(impl);
      TRACE_EVENT0("mojom", "WindowTree::GetWindowTree");
      mojo::internal::MessageDispatchContext context(message);
      impl->GetWindowTree(
std::move(p_window_id), std::move(callback));
      return true;
    }
    case internal::kWindowTree_Embed_Name: {
      internal::WindowTree_Embed_Params_Data* params =
          reinterpret_cast<internal::WindowTree_Embed_Params_Data*>(
              message->mutable_payload());
      
      mojo::internal::SerializationContext serialization_context;
      serialization_context.handles.Swap((message)->mutable_handles());
      serialization_context.associated_endpoint_handles.swap(
          *(message)->mutable_associated_endpoint_handles());
      bool success = true;
      uint32_t p_window_id{};
      WindowTreeClientPtr p_client{};
      uint32_t p_embed_flags{};
      WindowTree_Embed_ParamsDataView input_data_view(params, &serialization_context);
      
      p_window_id = input_data_view.window_id();
      p_client =
          input_data_view.TakeClient<decltype(p_client)>();
      p_embed_flags = input_data_view.embed_flags();
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            "WindowTree::Embed deserializer");
        return false;
      }
      WindowTree::EmbedCallback callback =
          WindowTree_Embed_ProxyToResponder::CreateCallback(
              message->request_id(),
              message->has_flag(mojo::Message::kFlagIsSync),
              std::move(responder));
      // A null |impl| means no implementation was bound.
      assert(impl);
      TRACE_EVENT0("mojom", "WindowTree::Embed");
      mojo::internal::MessageDispatchContext context(message);
      impl->Embed(
std::move(p_window_id), 
std::move(p_client), 
std::move(p_embed_flags), std::move(callback));
      return true;
    }
    case internal::kWindowTree_SetFocus_Name: {
      break;
    }
    case internal::kWindowTree_SetCanFocus_Name: {
      break;
    }
    case internal::kWindowTree_SetCursor_Name: {
      break;
    }
    case internal::kWindowTree_SetWindowTextInputState_Name: {
      break;
    }
    case internal::kWindowTree_SetImeVisibility_Name: {
      break;
    }
    case internal::kWindowTree_SetEventTargetingPolicy_Name: {
      break;
    }
    case internal::kWindowTree_OnWindowInputEventAck_Name: {
      break;
    }
    case internal::kWindowTree_DeactivateWindow_Name: {
      break;
    }
    case internal::kWindowTree_StackAbove_Name: {
      break;
    }
    case internal::kWindowTree_StackAtTop_Name: {
      break;
    }
    case internal::kWindowTree_GetWindowManagerClient_Name: {
      break;
    }
    case internal::kWindowTree_GetCursorLocationMemory_Name: {
      internal::WindowTree_GetCursorLocationMemory_Params_Data* params =
          reinterpret_cast<internal::WindowTree_GetCursorLocationMemory_Params_Data*>(
              message->mutable_payload());
      
      mojo::internal::SerializationContext serialization_context;
      serialization_context.handles.Swap((message)->mutable_handles());
      serialization_context.associated_endpoint_handles.swap(
          *(message)->mutable_associated_endpoint_handles());
      bool success = true;
      WindowTree_GetCursorLocationMemory_ParamsDataView input_data_view(params, &serialization_context);
      
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            "WindowTree::GetCursorLocationMemory deserializer");
        return false;
      }
      WindowTree::GetCursorLocationMemoryCallback callback =
          WindowTree_GetCursorLocationMemory_ProxyToResponder::CreateCallback(
              message->request_id(),
              message->has_flag(mojo::Message::kFlagIsSync),
              std::move(responder));
      // A null |impl| means no implementation was bound.
      assert(impl);
      TRACE_EVENT0("mojom", "WindowTree::GetCursorLocationMemory");
      mojo::internal::MessageDispatchContext context(message);
      impl->GetCursorLocationMemory(std::move(callback));
      return true;
    }
    case internal::kWindowTree_PerformWindowMove_Name: {
      break;
    }
    case internal::kWindowTree_CancelWindowMove_Name: {
      break;
    }
    case internal::kWindowTree_PerformDragDrop_Name: {
      break;
    }
    case internal::kWindowTree_CancelDragDrop_Name: {
      break;
    }
  }
  return false;
}

bool WindowTreeRequestValidator::Accept(mojo::Message* message) {
  if (mojo::internal::ControlMessageHandler::IsControlMessage(message))
    return true;

  mojo::internal::ValidationContext validation_context(
    message->payload(), message->payload_num_bytes(),
    message->handles()->size(), message->payload_num_interface_ids(), message,
    "WindowTree RequestValidator");

  switch (message->header()->name) {
    case internal::kWindowTree_NewWindow_Name: {
      if (!mojo::internal::ValidateMessageIsRequestWithoutResponse(
              message, &validation_context)) {
        return false;
      }
      if (!mojo::internal::ValidateMessagePayload<
               internal::WindowTree_NewWindow_Params_Data>(
                  message, &validation_context)) {
        return false;
      }
      return true;
    }
    case internal::kWindowTree_NewTopLevelWindow_Name: {
      if (!mojo::internal::ValidateMessageIsRequestWithoutResponse(
              message, &validation_context)) {
        return false;
      }
      if (!mojo::internal::ValidateMessagePayload<
               internal::WindowTree_NewTopLevelWindow_Params_Data>(
                  message, &validation_context)) {
        return false;
      }
      return true;
    }
    case internal::kWindowTree_DeleteWindow_Name: {
      if (!mojo::internal::ValidateMessageIsRequestWithoutResponse(
              message, &validation_context)) {
        return false;
      }
      if (!mojo::internal::ValidateMessagePayload<
               internal::WindowTree_DeleteWindow_Params_Data>(
                  message, &validation_context)) {
        return false;
      }
      return true;
    }
    case internal::kWindowTree_SetCapture_Name: {
      if (!mojo::internal::ValidateMessageIsRequestWithoutResponse(
              message, &validation_context)) {
        return false;
      }
      if (!mojo::internal::ValidateMessagePayload<
               internal::WindowTree_SetCapture_Params_Data>(
                  message, &validation_context)) {
        return false;
      }
      return true;
    }
    case internal::kWindowTree_ReleaseCapture_Name: {
      if (!mojo::internal::ValidateMessageIsRequestWithoutResponse(
              message, &validation_context)) {
        return false;
      }
      if (!mojo::internal::ValidateMessagePayload<
               internal::WindowTree_ReleaseCapture_Params_Data>(
                  message, &validation_context)) {
        return false;
      }
      return true;
    }
    case internal::kWindowTree_StartPointerWatcher_Name: {
      if (!mojo::internal::ValidateMessageIsRequestWithoutResponse(
              message, &validation_context)) {
        return false;
      }
      if (!mojo::internal::ValidateMessagePayload<
               internal::WindowTree_StartPointerWatcher_Params_Data>(
                  message, &validation_context)) {
        return false;
      }
      return true;
    }
    case internal::kWindowTree_StopPointerWatcher_Name: {
      if (!mojo::internal::ValidateMessageIsRequestWithoutResponse(
              message, &validation_context)) {
        return false;
      }
      if (!mojo::internal::ValidateMessagePayload<
               internal::WindowTree_StopPointerWatcher_Params_Data>(
                  message, &validation_context)) {
        return false;
      }
      return true;
    }
    case internal::kWindowTree_SetWindowBounds_Name: {
      if (!mojo::internal::ValidateMessageIsRequestWithoutResponse(
              message, &validation_context)) {
        return false;
      }
      if (!mojo::internal::ValidateMessagePayload<
               internal::WindowTree_SetWindowBounds_Params_Data>(
                  message, &validation_context)) {
        return false;
      }
      return true;
    }
    case internal::kWindowTree_SetClientArea_Name: {
      if (!mojo::internal::ValidateMessageIsRequestWithoutResponse(
              message, &validation_context)) {
        return false;
      }
      if (!mojo::internal::ValidateMessagePayload<
               internal::WindowTree_SetClientArea_Params_Data>(
                  message, &validation_context)) {
        return false;
      }
      return true;
    }
    case internal::kWindowTree_SetHitTestMask_Name: {
      if (!mojo::internal::ValidateMessageIsRequestWithoutResponse(
              message, &validation_context)) {
        return false;
      }
      if (!mojo::internal::ValidateMessagePayload<
               internal::WindowTree_SetHitTestMask_Params_Data>(
                  message, &validation_context)) {
        return false;
      }
      return true;
    }
    case internal::kWindowTree_SetCanAcceptDrops_Name: {
      if (!mojo::internal::ValidateMessageIsRequestWithoutResponse(
              message, &validation_context)) {
        return false;
      }
      if (!mojo::internal::ValidateMessagePayload<
               internal::WindowTree_SetCanAcceptDrops_Params_Data>(
                  message, &validation_context)) {
        return false;
      }
      return true;
    }
    case internal::kWindowTree_SetWindowVisibility_Name: {
      if (!mojo::internal::ValidateMessageIsRequestWithoutResponse(
              message, &validation_context)) {
        return false;
      }
      if (!mojo::internal::ValidateMessagePayload<
               internal::WindowTree_SetWindowVisibility_Params_Data>(
                  message, &validation_context)) {
        return false;
      }
      return true;
    }
    case internal::kWindowTree_SetWindowProperty_Name: {
      if (!mojo::internal::ValidateMessageIsRequestWithoutResponse(
              message, &validation_context)) {
        return false;
      }
      if (!mojo::internal::ValidateMessagePayload<
               internal::WindowTree_SetWindowProperty_Params_Data>(
                  message, &validation_context)) {
        return false;
      }
      return true;
    }
    case internal::kWindowTree_SetWindowOpacity_Name: {
      if (!mojo::internal::ValidateMessageIsRequestWithoutResponse(
              message, &validation_context)) {
        return false;
      }
      if (!mojo::internal::ValidateMessagePayload<
               internal::WindowTree_SetWindowOpacity_Params_Data>(
                  message, &validation_context)) {
        return false;
      }
      return true;
    }
    case internal::kWindowTree_AttachCompositorFrameSink_Name: {
      if (!mojo::internal::ValidateMessageIsRequestWithoutResponse(
              message, &validation_context)) {
        return false;
      }
      if (!mojo::internal::ValidateMessagePayload<
               internal::WindowTree_AttachCompositorFrameSink_Params_Data>(
                  message, &validation_context)) {
        return false;
      }
      return true;
    }
    case internal::kWindowTree_AddWindow_Name: {
      if (!mojo::internal::ValidateMessageIsRequestWithoutResponse(
              message, &validation_context)) {
        return false;
      }
      if (!mojo::internal::ValidateMessagePayload<
               internal::WindowTree_AddWindow_Params_Data>(
                  message, &validation_context)) {
        return false;
      }
      return true;
    }
    case internal::kWindowTree_RemoveWindowFromParent_Name: {
      if (!mojo::internal::ValidateMessageIsRequestWithoutResponse(
              message, &validation_context)) {
        return false;
      }
      if (!mojo::internal::ValidateMessagePayload<
               internal::WindowTree_RemoveWindowFromParent_Params_Data>(
                  message, &validation_context)) {
        return false;
      }
      return true;
    }
    case internal::kWindowTree_AddTransientWindow_Name: {
      if (!mojo::internal::ValidateMessageIsRequestWithoutResponse(
              message, &validation_context)) {
        return false;
      }
      if (!mojo::internal::ValidateMessagePayload<
               internal::WindowTree_AddTransientWindow_Params_Data>(
                  message, &validation_context)) {
        return false;
      }
      return true;
    }
    case internal::kWindowTree_RemoveTransientWindowFromParent_Name: {
      if (!mojo::internal::ValidateMessageIsRequestWithoutResponse(
              message, &validation_context)) {
        return false;
      }
      if (!mojo::internal::ValidateMessagePayload<
               internal::WindowTree_RemoveTransientWindowFromParent_Params_Data>(
                  message, &validation_context)) {
        return false;
      }
      return true;
    }
    case internal::kWindowTree_SetModalType_Name: {
      if (!mojo::internal::ValidateMessageIsRequestWithoutResponse(
              message, &validation_context)) {
        return false;
      }
      if (!mojo::internal::ValidateMessagePayload<
               internal::WindowTree_SetModalType_Params_Data>(
                  message, &validation_context)) {
        return false;
      }
      return true;
    }
    case internal::kWindowTree_ReorderWindow_Name: {
      if (!mojo::internal::ValidateMessageIsRequestWithoutResponse(
              message, &validation_context)) {
        return false;
      }
      if (!mojo::internal::ValidateMessagePayload<
               internal::WindowTree_ReorderWindow_Params_Data>(
                  message, &validation_context)) {
        return false;
      }
      return true;
    }
    case internal::kWindowTree_GetWindowTree_Name: {
      if (!mojo::internal::ValidateMessageIsRequestExpectingResponse(
              message, &validation_context)) {
        return false;
      }
      if (!mojo::internal::ValidateMessagePayload<
               internal::WindowTree_GetWindowTree_Params_Data>(
                  message, &validation_context)) {
        return false;
      }
      return true;
    }
    case internal::kWindowTree_Embed_Name: {
      if (!mojo::internal::ValidateMessageIsRequestExpectingResponse(
              message, &validation_context)) {
        return false;
      }
      if (!mojo::internal::ValidateMessagePayload<
               internal::WindowTree_Embed_Params_Data>(
                  message, &validation_context)) {
        return false;
      }
      return true;
    }
    case internal::kWindowTree_SetFocus_Name: {
      if (!mojo::internal::ValidateMessageIsRequestWithoutResponse(
              message, &validation_context)) {
        return false;
      }
      if (!mojo::internal::ValidateMessagePayload<
               internal::WindowTree_SetFocus_Params_Data>(
                  message, &validation_context)) {
        return false;
      }
      return true;
    }
    case internal::kWindowTree_SetCanFocus_Name: {
      if (!mojo::internal::ValidateMessageIsRequestWithoutResponse(
              message, &validation_context)) {
        return false;
      }
      if (!mojo::internal::ValidateMessagePayload<
               internal::WindowTree_SetCanFocus_Params_Data>(
                  message, &validation_context)) {
        return false;
      }
      return true;
    }
    case internal::kWindowTree_SetCursor_Name: {
      if (!mojo::internal::ValidateMessageIsRequestWithoutResponse(
              message, &validation_context)) {
        return false;
      }
      if (!mojo::internal::ValidateMessagePayload<
               internal::WindowTree_SetCursor_Params_Data>(
                  message, &validation_context)) {
        return false;
      }
      return true;
    }
    case internal::kWindowTree_SetWindowTextInputState_Name: {
      if (!mojo::internal::ValidateMessageIsRequestWithoutResponse(
              message, &validation_context)) {
        return false;
      }
      if (!mojo::internal::ValidateMessagePayload<
               internal::WindowTree_SetWindowTextInputState_Params_Data>(
                  message, &validation_context)) {
        return false;
      }
      return true;
    }
    case internal::kWindowTree_SetImeVisibility_Name: {
      if (!mojo::internal::ValidateMessageIsRequestWithoutResponse(
              message, &validation_context)) {
        return false;
      }
      if (!mojo::internal::ValidateMessagePayload<
               internal::WindowTree_SetImeVisibility_Params_Data>(
                  message, &validation_context)) {
        return false;
      }
      return true;
    }
    case internal::kWindowTree_SetEventTargetingPolicy_Name: {
      if (!mojo::internal::ValidateMessageIsRequestWithoutResponse(
              message, &validation_context)) {
        return false;
      }
      if (!mojo::internal::ValidateMessagePayload<
               internal::WindowTree_SetEventTargetingPolicy_Params_Data>(
                  message, &validation_context)) {
        return false;
      }
      return true;
    }
    case internal::kWindowTree_OnWindowInputEventAck_Name: {
      if (!mojo::internal::ValidateMessageIsRequestWithoutResponse(
              message, &validation_context)) {
        return false;
      }
      if (!mojo::internal::ValidateMessagePayload<
               internal::WindowTree_OnWindowInputEventAck_Params_Data>(
                  message, &validation_context)) {
        return false;
      }
      return true;
    }
    case internal::kWindowTree_DeactivateWindow_Name: {
      if (!mojo::internal::ValidateMessageIsRequestWithoutResponse(
              message, &validation_context)) {
        return false;
      }
      if (!mojo::internal::ValidateMessagePayload<
               internal::WindowTree_DeactivateWindow_Params_Data>(
                  message, &validation_context)) {
        return false;
      }
      return true;
    }
    case internal::kWindowTree_StackAbove_Name: {
      if (!mojo::internal::ValidateMessageIsRequestWithoutResponse(
              message, &validation_context)) {
        return false;
      }
      if (!mojo::internal::ValidateMessagePayload<
               internal::WindowTree_StackAbove_Params_Data>(
                  message, &validation_context)) {
        return false;
      }
      return true;
    }
    case internal::kWindowTree_StackAtTop_Name: {
      if (!mojo::internal::ValidateMessageIsRequestWithoutResponse(
              message, &validation_context)) {
        return false;
      }
      if (!mojo::internal::ValidateMessagePayload<
               internal::WindowTree_StackAtTop_Params_Data>(
                  message, &validation_context)) {
        return false;
      }
      return true;
    }
    case internal::kWindowTree_GetWindowManagerClient_Name: {
      if (!mojo::internal::ValidateMessageIsRequestWithoutResponse(
              message, &validation_context)) {
        return false;
      }
      if (!mojo::internal::ValidateMessagePayload<
               internal::WindowTree_GetWindowManagerClient_Params_Data>(
                  message, &validation_context)) {
        return false;
      }
      return true;
    }
    case internal::kWindowTree_GetCursorLocationMemory_Name: {
      if (!mojo::internal::ValidateMessageIsRequestExpectingResponse(
              message, &validation_context)) {
        return false;
      }
      if (!mojo::internal::ValidateMessagePayload<
               internal::WindowTree_GetCursorLocationMemory_Params_Data>(
                  message, &validation_context)) {
        return false;
      }
      return true;
    }
    case internal::kWindowTree_PerformWindowMove_Name: {
      if (!mojo::internal::ValidateMessageIsRequestWithoutResponse(
              message, &validation_context)) {
        return false;
      }
      if (!mojo::internal::ValidateMessagePayload<
               internal::WindowTree_PerformWindowMove_Params_Data>(
                  message, &validation_context)) {
        return false;
      }
      return true;
    }
    case internal::kWindowTree_CancelWindowMove_Name: {
      if (!mojo::internal::ValidateMessageIsRequestWithoutResponse(
              message, &validation_context)) {
        return false;
      }
      if (!mojo::internal::ValidateMessagePayload<
               internal::WindowTree_CancelWindowMove_Params_Data>(
                  message, &validation_context)) {
        return false;
      }
      return true;
    }
    case internal::kWindowTree_PerformDragDrop_Name: {
      if (!mojo::internal::ValidateMessageIsRequestWithoutResponse(
              message, &validation_context)) {
        return false;
      }
      if (!mojo::internal::ValidateMessagePayload<
               internal::WindowTree_PerformDragDrop_Params_Data>(
                  message, &validation_context)) {
        return false;
      }
      return true;
    }
    case internal::kWindowTree_CancelDragDrop_Name: {
      if (!mojo::internal::ValidateMessageIsRequestWithoutResponse(
              message, &validation_context)) {
        return false;
      }
      if (!mojo::internal::ValidateMessagePayload<
               internal::WindowTree_CancelDragDrop_Params_Data>(
                  message, &validation_context)) {
        return false;
      }
      return true;
    }
    default:
      break;
  }

  // Unrecognized message.
  ReportValidationError(
      &validation_context,
      mojo::internal::VALIDATION_ERROR_MESSAGE_HEADER_UNKNOWN_METHOD);
  return false;
}

bool WindowTreeResponseValidator::Accept(mojo::Message* message) {
  if (mojo::internal::ControlMessageHandler::IsControlMessage(message))
    return true;

  mojo::internal::ValidationContext validation_context(
    message->payload(), message->payload_num_bytes(),
    message->handles()->size(), message->payload_num_interface_ids(), message,
    "WindowTree ResponseValidator");

  if (!mojo::internal::ValidateMessageIsResponse(message, &validation_context))
    return false;
  switch (message->header()->name) {
    case internal::kWindowTree_GetWindowTree_Name: {
      if (!mojo::internal::ValidateMessagePayload<
               internal::WindowTree_GetWindowTree_ResponseParams_Data>(
                    message, &validation_context)) {
        return false;
      }
      return true;
    }
    case internal::kWindowTree_Embed_Name: {
      if (!mojo::internal::ValidateMessagePayload<
               internal::WindowTree_Embed_ResponseParams_Data>(
                    message, &validation_context)) {
        return false;
      }
      return true;
    }
    case internal::kWindowTree_GetCursorLocationMemory_Name: {
      if (!mojo::internal::ValidateMessagePayload<
               internal::WindowTree_GetCursorLocationMemory_ResponseParams_Data>(
                    message, &validation_context)) {
        return false;
      }
      return true;
    }
    default:
      break;
  }

  // Unrecognized message.
  ReportValidationError(
      &validation_context,
      mojo::internal::VALIDATION_ERROR_MESSAGE_HEADER_UNKNOWN_METHOD);
  return false;
}
const char WindowTreeClient::Name_[] = "ui::mojom::WindowTreeClient";

class WindowTreeClient_OnDragEnter_ForwardToCallback
    : public mojo::MessageReceiver {
 public:
  WindowTreeClient_OnDragEnter_ForwardToCallback(
      const WindowTreeClient::OnDragEnterCallback& callback
      ) : callback_(std::move(callback)) {
  }
  bool Accept(mojo::Message* message) override;
 private:
  WindowTreeClient::OnDragEnterCallback callback_;
  DISALLOW_COPY_AND_ASSIGN(WindowTreeClient_OnDragEnter_ForwardToCallback);
};
bool WindowTreeClient_OnDragEnter_ForwardToCallback::Accept(
    mojo::Message* message) {
  internal::WindowTreeClient_OnDragEnter_ResponseParams_Data* params =
      reinterpret_cast<internal::WindowTreeClient_OnDragEnter_ResponseParams_Data*>(
          message->mutable_payload());
  
  mojo::internal::SerializationContext serialization_context;
  serialization_context.handles.Swap((message)->mutable_handles());
  serialization_context.associated_endpoint_handles.swap(
      *(message)->mutable_associated_endpoint_handles());
  bool success = true;
  uint32_t p_supported_op_bitmask{};
  WindowTreeClient_OnDragEnter_ResponseParamsDataView input_data_view(params, &serialization_context);
  
  p_supported_op_bitmask = input_data_view.supported_op_bitmask();
  if (!success) {
    ReportValidationErrorForMessage(
        message,
        mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
        "WindowTreeClient::OnDragEnter response deserializer");
    return false;
  }
  if (!callback_.is_null()) {
    mojo::internal::MessageDispatchContext context(message);
    std::move(callback_).Run(
std::move(p_supported_op_bitmask));
  }
  return true;
}

class WindowTreeClient_OnDragOver_ForwardToCallback
    : public mojo::MessageReceiver {
 public:
  WindowTreeClient_OnDragOver_ForwardToCallback(
      const WindowTreeClient::OnDragOverCallback& callback
      ) : callback_(std::move(callback)) {
  }
  bool Accept(mojo::Message* message) override;
 private:
  WindowTreeClient::OnDragOverCallback callback_;
  DISALLOW_COPY_AND_ASSIGN(WindowTreeClient_OnDragOver_ForwardToCallback);
};
bool WindowTreeClient_OnDragOver_ForwardToCallback::Accept(
    mojo::Message* message) {
  internal::WindowTreeClient_OnDragOver_ResponseParams_Data* params =
      reinterpret_cast<internal::WindowTreeClient_OnDragOver_ResponseParams_Data*>(
          message->mutable_payload());
  
  mojo::internal::SerializationContext serialization_context;
  serialization_context.handles.Swap((message)->mutable_handles());
  serialization_context.associated_endpoint_handles.swap(
      *(message)->mutable_associated_endpoint_handles());
  bool success = true;
  uint32_t p_supported_op_bitmask{};
  WindowTreeClient_OnDragOver_ResponseParamsDataView input_data_view(params, &serialization_context);
  
  p_supported_op_bitmask = input_data_view.supported_op_bitmask();
  if (!success) {
    ReportValidationErrorForMessage(
        message,
        mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
        "WindowTreeClient::OnDragOver response deserializer");
    return false;
  }
  if (!callback_.is_null()) {
    mojo::internal::MessageDispatchContext context(message);
    std::move(callback_).Run(
std::move(p_supported_op_bitmask));
  }
  return true;
}

class WindowTreeClient_OnCompleteDrop_ForwardToCallback
    : public mojo::MessageReceiver {
 public:
  WindowTreeClient_OnCompleteDrop_ForwardToCallback(
      const WindowTreeClient::OnCompleteDropCallback& callback
      ) : callback_(std::move(callback)) {
  }
  bool Accept(mojo::Message* message) override;
 private:
  WindowTreeClient::OnCompleteDropCallback callback_;
  DISALLOW_COPY_AND_ASSIGN(WindowTreeClient_OnCompleteDrop_ForwardToCallback);
};
bool WindowTreeClient_OnCompleteDrop_ForwardToCallback::Accept(
    mojo::Message* message) {
  internal::WindowTreeClient_OnCompleteDrop_ResponseParams_Data* params =
      reinterpret_cast<internal::WindowTreeClient_OnCompleteDrop_ResponseParams_Data*>(
          message->mutable_payload());
  
  mojo::internal::SerializationContext serialization_context;
  serialization_context.handles.Swap((message)->mutable_handles());
  serialization_context.associated_endpoint_handles.swap(
      *(message)->mutable_associated_endpoint_handles());
  bool success = true;
  uint32_t p_action_taken{};
  WindowTreeClient_OnCompleteDrop_ResponseParamsDataView input_data_view(params, &serialization_context);
  
  p_action_taken = input_data_view.action_taken();
  if (!success) {
    ReportValidationErrorForMessage(
        message,
        mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
        "WindowTreeClient::OnCompleteDrop response deserializer");
    return false;
  }
  if (!callback_.is_null()) {
    mojo::internal::MessageDispatchContext context(message);
    std::move(callback_).Run(
std::move(p_action_taken));
  }
  return true;
}

WindowTreeClientProxy::WindowTreeClientProxy(mojo::MessageReceiverWithResponder* receiver)
    : receiver_(receiver) {
}

void WindowTreeClientProxy::OnEmbed(
    uint16_t in_connection_id, ::ui::mojom::blink::WindowDataPtr in_root, WindowTreePtr in_tree, int64_t in_display_id, uint32_t in_focused_window, bool in_parent_drawn, const cc::FrameSinkId& in_frame_sink_id, const WTF::Optional<cc::LocalSurfaceId>& in_local_surface_id) {
  mojo::internal::SerializationContext serialization_context;
  size_t size = sizeof(::ui::mojom::internal::WindowTreeClient_OnEmbed_Params_Data);
  size += mojo::internal::PrepareToSerialize<::ui::mojom::WindowDataDataView>(
      in_root, &serialization_context);
  size += mojo::internal::PrepareToSerialize<::cc::mojom::FrameSinkIdDataView>(
      in_frame_sink_id, &serialization_context);
  size += mojo::internal::PrepareToSerialize<::cc::mojom::LocalSurfaceIdDataView>(
      in_local_surface_id, &serialization_context);
  constexpr uint32_t kFlags = 0;
  mojo::internal::MessageBuilder builder(
      internal::kWindowTreeClient_OnEmbed_Name, kFlags, size,
      serialization_context.associated_endpoint_count);

  auto params =
      ::ui::mojom::internal::WindowTreeClient_OnEmbed_Params_Data::New(builder.buffer());
  ALLOW_UNUSED_LOCAL(params);
  params->connection_id = in_connection_id;
  typename decltype(params->root)::BaseType* root_ptr;
  mojo::internal::Serialize<::ui::mojom::WindowDataDataView>(
      in_root, builder.buffer(), &root_ptr, &serialization_context);
  params->root.Set(root_ptr);
  MOJO_INTERNAL_DLOG_SERIALIZATION_WARNING(
      params->root.is_null(),
      mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
      "null root in WindowTreeClient.OnEmbed request");
  mojo::internal::Serialize<::ui::mojom::WindowTreePtrDataView>(
      in_tree, &params->tree, &serialization_context);
  params->display_id = in_display_id;
  params->focused_window = in_focused_window;
  params->parent_drawn = in_parent_drawn;
  typename decltype(params->frame_sink_id)::BaseType* frame_sink_id_ptr;
  mojo::internal::Serialize<::cc::mojom::FrameSinkIdDataView>(
      in_frame_sink_id, builder.buffer(), &frame_sink_id_ptr, &serialization_context);
  params->frame_sink_id.Set(frame_sink_id_ptr);
  MOJO_INTERNAL_DLOG_SERIALIZATION_WARNING(
      params->frame_sink_id.is_null(),
      mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
      "null frame_sink_id in WindowTreeClient.OnEmbed request");
  typename decltype(params->local_surface_id)::BaseType* local_surface_id_ptr;
  mojo::internal::Serialize<::cc::mojom::LocalSurfaceIdDataView>(
      in_local_surface_id, builder.buffer(), &local_surface_id_ptr, &serialization_context);
  params->local_surface_id.Set(local_surface_id_ptr);
  (&serialization_context)->handles.Swap(
      builder.message()->mutable_handles());
  (&serialization_context)->associated_endpoint_handles.swap(
      *builder.message()->mutable_associated_endpoint_handles());
  // This return value may be ignored as false implies the Connector has
  // encountered an error, which will be visible through other means.
  ignore_result(receiver_->Accept(builder.message()));
}

void WindowTreeClientProxy::OnEmbeddedAppDisconnected(
    uint32_t in_window) {
  mojo::internal::SerializationContext serialization_context;
  size_t size = sizeof(::ui::mojom::internal::WindowTreeClient_OnEmbeddedAppDisconnected_Params_Data);
  constexpr uint32_t kFlags = 0;
  mojo::internal::MessageBuilder builder(
      internal::kWindowTreeClient_OnEmbeddedAppDisconnected_Name, kFlags, size,
      serialization_context.associated_endpoint_count);

  auto params =
      ::ui::mojom::internal::WindowTreeClient_OnEmbeddedAppDisconnected_Params_Data::New(builder.buffer());
  ALLOW_UNUSED_LOCAL(params);
  params->window = in_window;
  (&serialization_context)->handles.Swap(
      builder.message()->mutable_handles());
  (&serialization_context)->associated_endpoint_handles.swap(
      *builder.message()->mutable_associated_endpoint_handles());
  // This return value may be ignored as false implies the Connector has
  // encountered an error, which will be visible through other means.
  ignore_result(receiver_->Accept(builder.message()));
}

void WindowTreeClientProxy::OnUnembed(
    uint32_t in_window) {
  mojo::internal::SerializationContext serialization_context;
  size_t size = sizeof(::ui::mojom::internal::WindowTreeClient_OnUnembed_Params_Data);
  constexpr uint32_t kFlags = 0;
  mojo::internal::MessageBuilder builder(
      internal::kWindowTreeClient_OnUnembed_Name, kFlags, size,
      serialization_context.associated_endpoint_count);

  auto params =
      ::ui::mojom::internal::WindowTreeClient_OnUnembed_Params_Data::New(builder.buffer());
  ALLOW_UNUSED_LOCAL(params);
  params->window = in_window;
  (&serialization_context)->handles.Swap(
      builder.message()->mutable_handles());
  (&serialization_context)->associated_endpoint_handles.swap(
      *builder.message()->mutable_associated_endpoint_handles());
  // This return value may be ignored as false implies the Connector has
  // encountered an error, which will be visible through other means.
  ignore_result(receiver_->Accept(builder.message()));
}

void WindowTreeClientProxy::OnCaptureChanged(
    uint32_t in_new_capture, uint32_t in_old_capture) {
  mojo::internal::SerializationContext serialization_context;
  size_t size = sizeof(::ui::mojom::internal::WindowTreeClient_OnCaptureChanged_Params_Data);
  constexpr uint32_t kFlags = 0;
  mojo::internal::MessageBuilder builder(
      internal::kWindowTreeClient_OnCaptureChanged_Name, kFlags, size,
      serialization_context.associated_endpoint_count);

  auto params =
      ::ui::mojom::internal::WindowTreeClient_OnCaptureChanged_Params_Data::New(builder.buffer());
  ALLOW_UNUSED_LOCAL(params);
  params->new_capture = in_new_capture;
  params->old_capture = in_old_capture;
  (&serialization_context)->handles.Swap(
      builder.message()->mutable_handles());
  (&serialization_context)->associated_endpoint_handles.swap(
      *builder.message()->mutable_associated_endpoint_handles());
  // This return value may be ignored as false implies the Connector has
  // encountered an error, which will be visible through other means.
  ignore_result(receiver_->Accept(builder.message()));
}

void WindowTreeClientProxy::OnFrameSinkIdAllocated(
    uint32_t in_window, const cc::FrameSinkId& in_frame_sink_id) {
  mojo::internal::SerializationContext serialization_context;
  size_t size = sizeof(::ui::mojom::internal::WindowTreeClient_OnFrameSinkIdAllocated_Params_Data);
  size += mojo::internal::PrepareToSerialize<::cc::mojom::FrameSinkIdDataView>(
      in_frame_sink_id, &serialization_context);
  constexpr uint32_t kFlags = 0;
  mojo::internal::MessageBuilder builder(
      internal::kWindowTreeClient_OnFrameSinkIdAllocated_Name, kFlags, size,
      serialization_context.associated_endpoint_count);

  auto params =
      ::ui::mojom::internal::WindowTreeClient_OnFrameSinkIdAllocated_Params_Data::New(builder.buffer());
  ALLOW_UNUSED_LOCAL(params);
  params->window = in_window;
  typename decltype(params->frame_sink_id)::BaseType* frame_sink_id_ptr;
  mojo::internal::Serialize<::cc::mojom::FrameSinkIdDataView>(
      in_frame_sink_id, builder.buffer(), &frame_sink_id_ptr, &serialization_context);
  params->frame_sink_id.Set(frame_sink_id_ptr);
  MOJO_INTERNAL_DLOG_SERIALIZATION_WARNING(
      params->frame_sink_id.is_null(),
      mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
      "null frame_sink_id in WindowTreeClient.OnFrameSinkIdAllocated request");
  (&serialization_context)->handles.Swap(
      builder.message()->mutable_handles());
  (&serialization_context)->associated_endpoint_handles.swap(
      *builder.message()->mutable_associated_endpoint_handles());
  // This return value may be ignored as false implies the Connector has
  // encountered an error, which will be visible through other means.
  ignore_result(receiver_->Accept(builder.message()));
}

void WindowTreeClientProxy::OnTopLevelCreated(
    uint32_t in_change_id, ::ui::mojom::blink::WindowDataPtr in_data, int64_t in_display_id, bool in_parent_drawn, const cc::FrameSinkId& in_frame_sink_id, const WTF::Optional<cc::LocalSurfaceId>& in_local_surface_id) {
  mojo::internal::SerializationContext serialization_context;
  size_t size = sizeof(::ui::mojom::internal::WindowTreeClient_OnTopLevelCreated_Params_Data);
  size += mojo::internal::PrepareToSerialize<::ui::mojom::WindowDataDataView>(
      in_data, &serialization_context);
  size += mojo::internal::PrepareToSerialize<::cc::mojom::FrameSinkIdDataView>(
      in_frame_sink_id, &serialization_context);
  size += mojo::internal::PrepareToSerialize<::cc::mojom::LocalSurfaceIdDataView>(
      in_local_surface_id, &serialization_context);
  constexpr uint32_t kFlags = 0;
  mojo::internal::MessageBuilder builder(
      internal::kWindowTreeClient_OnTopLevelCreated_Name, kFlags, size,
      serialization_context.associated_endpoint_count);

  auto params =
      ::ui::mojom::internal::WindowTreeClient_OnTopLevelCreated_Params_Data::New(builder.buffer());
  ALLOW_UNUSED_LOCAL(params);
  params->change_id = in_change_id;
  typename decltype(params->data)::BaseType* data_ptr;
  mojo::internal::Serialize<::ui::mojom::WindowDataDataView>(
      in_data, builder.buffer(), &data_ptr, &serialization_context);
  params->data.Set(data_ptr);
  MOJO_INTERNAL_DLOG_SERIALIZATION_WARNING(
      params->data.is_null(),
      mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
      "null data in WindowTreeClient.OnTopLevelCreated request");
  params->display_id = in_display_id;
  params->parent_drawn = in_parent_drawn;
  typename decltype(params->frame_sink_id)::BaseType* frame_sink_id_ptr;
  mojo::internal::Serialize<::cc::mojom::FrameSinkIdDataView>(
      in_frame_sink_id, builder.buffer(), &frame_sink_id_ptr, &serialization_context);
  params->frame_sink_id.Set(frame_sink_id_ptr);
  MOJO_INTERNAL_DLOG_SERIALIZATION_WARNING(
      params->frame_sink_id.is_null(),
      mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
      "null frame_sink_id in WindowTreeClient.OnTopLevelCreated request");
  typename decltype(params->local_surface_id)::BaseType* local_surface_id_ptr;
  mojo::internal::Serialize<::cc::mojom::LocalSurfaceIdDataView>(
      in_local_surface_id, builder.buffer(), &local_surface_id_ptr, &serialization_context);
  params->local_surface_id.Set(local_surface_id_ptr);
  (&serialization_context)->handles.Swap(
      builder.message()->mutable_handles());
  (&serialization_context)->associated_endpoint_handles.swap(
      *builder.message()->mutable_associated_endpoint_handles());
  // This return value may be ignored as false implies the Connector has
  // encountered an error, which will be visible through other means.
  ignore_result(receiver_->Accept(builder.message()));
}

void WindowTreeClientProxy::OnWindowBoundsChanged(
    uint32_t in_window, ::gfx::mojom::blink::RectPtr in_old_bounds, ::gfx::mojom::blink::RectPtr in_new_bounds, const WTF::Optional<cc::LocalSurfaceId>& in_local_surface_id) {
  mojo::internal::SerializationContext serialization_context;
  size_t size = sizeof(::ui::mojom::internal::WindowTreeClient_OnWindowBoundsChanged_Params_Data);
  size += mojo::internal::PrepareToSerialize<::gfx::mojom::RectDataView>(
      in_old_bounds, &serialization_context);
  size += mojo::internal::PrepareToSerialize<::gfx::mojom::RectDataView>(
      in_new_bounds, &serialization_context);
  size += mojo::internal::PrepareToSerialize<::cc::mojom::LocalSurfaceIdDataView>(
      in_local_surface_id, &serialization_context);
  constexpr uint32_t kFlags = 0;
  mojo::internal::MessageBuilder builder(
      internal::kWindowTreeClient_OnWindowBoundsChanged_Name, kFlags, size,
      serialization_context.associated_endpoint_count);

  auto params =
      ::ui::mojom::internal::WindowTreeClient_OnWindowBoundsChanged_Params_Data::New(builder.buffer());
  ALLOW_UNUSED_LOCAL(params);
  params->window = in_window;
  typename decltype(params->old_bounds)::BaseType* old_bounds_ptr;
  mojo::internal::Serialize<::gfx::mojom::RectDataView>(
      in_old_bounds, builder.buffer(), &old_bounds_ptr, &serialization_context);
  params->old_bounds.Set(old_bounds_ptr);
  MOJO_INTERNAL_DLOG_SERIALIZATION_WARNING(
      params->old_bounds.is_null(),
      mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
      "null old_bounds in WindowTreeClient.OnWindowBoundsChanged request");
  typename decltype(params->new_bounds)::BaseType* new_bounds_ptr;
  mojo::internal::Serialize<::gfx::mojom::RectDataView>(
      in_new_bounds, builder.buffer(), &new_bounds_ptr, &serialization_context);
  params->new_bounds.Set(new_bounds_ptr);
  MOJO_INTERNAL_DLOG_SERIALIZATION_WARNING(
      params->new_bounds.is_null(),
      mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
      "null new_bounds in WindowTreeClient.OnWindowBoundsChanged request");
  typename decltype(params->local_surface_id)::BaseType* local_surface_id_ptr;
  mojo::internal::Serialize<::cc::mojom::LocalSurfaceIdDataView>(
      in_local_surface_id, builder.buffer(), &local_surface_id_ptr, &serialization_context);
  params->local_surface_id.Set(local_surface_id_ptr);
  (&serialization_context)->handles.Swap(
      builder.message()->mutable_handles());
  (&serialization_context)->associated_endpoint_handles.swap(
      *builder.message()->mutable_associated_endpoint_handles());
  // This return value may be ignored as false implies the Connector has
  // encountered an error, which will be visible through other means.
  ignore_result(receiver_->Accept(builder.message()));
}

void WindowTreeClientProxy::OnClientAreaChanged(
    uint32_t in_window_id, ::gfx::mojom::blink::InsetsPtr in_new_client_area, WTF::Vector<::gfx::mojom::blink::RectPtr> in_new_additional_client_areas) {
  mojo::internal::SerializationContext serialization_context;
  size_t size = sizeof(::ui::mojom::internal::WindowTreeClient_OnClientAreaChanged_Params_Data);
  size += mojo::internal::PrepareToSerialize<::gfx::mojom::InsetsDataView>(
      in_new_client_area, &serialization_context);
  size += mojo::internal::PrepareToSerialize<mojo::ArrayDataView<::gfx::mojom::RectDataView>>(
      in_new_additional_client_areas, &serialization_context);
  constexpr uint32_t kFlags = 0;
  mojo::internal::MessageBuilder builder(
      internal::kWindowTreeClient_OnClientAreaChanged_Name, kFlags, size,
      serialization_context.associated_endpoint_count);

  auto params =
      ::ui::mojom::internal::WindowTreeClient_OnClientAreaChanged_Params_Data::New(builder.buffer());
  ALLOW_UNUSED_LOCAL(params);
  params->window_id = in_window_id;
  typename decltype(params->new_client_area)::BaseType* new_client_area_ptr;
  mojo::internal::Serialize<::gfx::mojom::InsetsDataView>(
      in_new_client_area, builder.buffer(), &new_client_area_ptr, &serialization_context);
  params->new_client_area.Set(new_client_area_ptr);
  MOJO_INTERNAL_DLOG_SERIALIZATION_WARNING(
      params->new_client_area.is_null(),
      mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
      "null new_client_area in WindowTreeClient.OnClientAreaChanged request");
  typename decltype(params->new_additional_client_areas)::BaseType* new_additional_client_areas_ptr;
  const mojo::internal::ContainerValidateParams new_additional_client_areas_validate_params(
      0, false, nullptr);
  mojo::internal::Serialize<mojo::ArrayDataView<::gfx::mojom::RectDataView>>(
      in_new_additional_client_areas, builder.buffer(), &new_additional_client_areas_ptr, &new_additional_client_areas_validate_params,
      &serialization_context);
  params->new_additional_client_areas.Set(new_additional_client_areas_ptr);
  MOJO_INTERNAL_DLOG_SERIALIZATION_WARNING(
      params->new_additional_client_areas.is_null(),
      mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
      "null new_additional_client_areas in WindowTreeClient.OnClientAreaChanged request");
  (&serialization_context)->handles.Swap(
      builder.message()->mutable_handles());
  (&serialization_context)->associated_endpoint_handles.swap(
      *builder.message()->mutable_associated_endpoint_handles());
  // This return value may be ignored as false implies the Connector has
  // encountered an error, which will be visible through other means.
  ignore_result(receiver_->Accept(builder.message()));
}

void WindowTreeClientProxy::OnTransientWindowAdded(
    uint32_t in_window_id, uint32_t in_transient_window_id) {
  mojo::internal::SerializationContext serialization_context;
  size_t size = sizeof(::ui::mojom::internal::WindowTreeClient_OnTransientWindowAdded_Params_Data);
  constexpr uint32_t kFlags = 0;
  mojo::internal::MessageBuilder builder(
      internal::kWindowTreeClient_OnTransientWindowAdded_Name, kFlags, size,
      serialization_context.associated_endpoint_count);

  auto params =
      ::ui::mojom::internal::WindowTreeClient_OnTransientWindowAdded_Params_Data::New(builder.buffer());
  ALLOW_UNUSED_LOCAL(params);
  params->window_id = in_window_id;
  params->transient_window_id = in_transient_window_id;
  (&serialization_context)->handles.Swap(
      builder.message()->mutable_handles());
  (&serialization_context)->associated_endpoint_handles.swap(
      *builder.message()->mutable_associated_endpoint_handles());
  // This return value may be ignored as false implies the Connector has
  // encountered an error, which will be visible through other means.
  ignore_result(receiver_->Accept(builder.message()));
}

void WindowTreeClientProxy::OnTransientWindowRemoved(
    uint32_t in_window_id, uint32_t in_transient_window_id) {
  mojo::internal::SerializationContext serialization_context;
  size_t size = sizeof(::ui::mojom::internal::WindowTreeClient_OnTransientWindowRemoved_Params_Data);
  constexpr uint32_t kFlags = 0;
  mojo::internal::MessageBuilder builder(
      internal::kWindowTreeClient_OnTransientWindowRemoved_Name, kFlags, size,
      serialization_context.associated_endpoint_count);

  auto params =
      ::ui::mojom::internal::WindowTreeClient_OnTransientWindowRemoved_Params_Data::New(builder.buffer());
  ALLOW_UNUSED_LOCAL(params);
  params->window_id = in_window_id;
  params->transient_window_id = in_transient_window_id;
  (&serialization_context)->handles.Swap(
      builder.message()->mutable_handles());
  (&serialization_context)->associated_endpoint_handles.swap(
      *builder.message()->mutable_associated_endpoint_handles());
  // This return value may be ignored as false implies the Connector has
  // encountered an error, which will be visible through other means.
  ignore_result(receiver_->Accept(builder.message()));
}

void WindowTreeClientProxy::OnWindowHierarchyChanged(
    uint32_t in_window, uint32_t in_old_parent, uint32_t in_new_parent, WTF::Vector<::ui::mojom::blink::WindowDataPtr> in_windows) {
  mojo::internal::SerializationContext serialization_context;
  size_t size = sizeof(::ui::mojom::internal::WindowTreeClient_OnWindowHierarchyChanged_Params_Data);
  size += mojo::internal::PrepareToSerialize<mojo::ArrayDataView<::ui::mojom::WindowDataDataView>>(
      in_windows, &serialization_context);
  constexpr uint32_t kFlags = 0;
  mojo::internal::MessageBuilder builder(
      internal::kWindowTreeClient_OnWindowHierarchyChanged_Name, kFlags, size,
      serialization_context.associated_endpoint_count);

  auto params =
      ::ui::mojom::internal::WindowTreeClient_OnWindowHierarchyChanged_Params_Data::New(builder.buffer());
  ALLOW_UNUSED_LOCAL(params);
  params->window = in_window;
  params->old_parent = in_old_parent;
  params->new_parent = in_new_parent;
  typename decltype(params->windows)::BaseType* windows_ptr;
  const mojo::internal::ContainerValidateParams windows_validate_params(
      0, false, nullptr);
  mojo::internal::Serialize<mojo::ArrayDataView<::ui::mojom::WindowDataDataView>>(
      in_windows, builder.buffer(), &windows_ptr, &windows_validate_params,
      &serialization_context);
  params->windows.Set(windows_ptr);
  MOJO_INTERNAL_DLOG_SERIALIZATION_WARNING(
      params->windows.is_null(),
      mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
      "null windows in WindowTreeClient.OnWindowHierarchyChanged request");
  (&serialization_context)->handles.Swap(
      builder.message()->mutable_handles());
  (&serialization_context)->associated_endpoint_handles.swap(
      *builder.message()->mutable_associated_endpoint_handles());
  // This return value may be ignored as false implies the Connector has
  // encountered an error, which will be visible through other means.
  ignore_result(receiver_->Accept(builder.message()));
}

void WindowTreeClientProxy::OnWindowReordered(
    uint32_t in_window_id, uint32_t in_relative_window_id, ::ui::mojom::blink::OrderDirection in_direction) {
  mojo::internal::SerializationContext serialization_context;
  size_t size = sizeof(::ui::mojom::internal::WindowTreeClient_OnWindowReordered_Params_Data);
  constexpr uint32_t kFlags = 0;
  mojo::internal::MessageBuilder builder(
      internal::kWindowTreeClient_OnWindowReordered_Name, kFlags, size,
      serialization_context.associated_endpoint_count);

  auto params =
      ::ui::mojom::internal::WindowTreeClient_OnWindowReordered_Params_Data::New(builder.buffer());
  ALLOW_UNUSED_LOCAL(params);
  params->window_id = in_window_id;
  params->relative_window_id = in_relative_window_id;
  mojo::internal::Serialize<::ui::mojom::OrderDirection>(
      in_direction, &params->direction);
  (&serialization_context)->handles.Swap(
      builder.message()->mutable_handles());
  (&serialization_context)->associated_endpoint_handles.swap(
      *builder.message()->mutable_associated_endpoint_handles());
  // This return value may be ignored as false implies the Connector has
  // encountered an error, which will be visible through other means.
  ignore_result(receiver_->Accept(builder.message()));
}

void WindowTreeClientProxy::OnWindowDeleted(
    uint32_t in_window) {
  mojo::internal::SerializationContext serialization_context;
  size_t size = sizeof(::ui::mojom::internal::WindowTreeClient_OnWindowDeleted_Params_Data);
  constexpr uint32_t kFlags = 0;
  mojo::internal::MessageBuilder builder(
      internal::kWindowTreeClient_OnWindowDeleted_Name, kFlags, size,
      serialization_context.associated_endpoint_count);

  auto params =
      ::ui::mojom::internal::WindowTreeClient_OnWindowDeleted_Params_Data::New(builder.buffer());
  ALLOW_UNUSED_LOCAL(params);
  params->window = in_window;
  (&serialization_context)->handles.Swap(
      builder.message()->mutable_handles());
  (&serialization_context)->associated_endpoint_handles.swap(
      *builder.message()->mutable_associated_endpoint_handles());
  // This return value may be ignored as false implies the Connector has
  // encountered an error, which will be visible through other means.
  ignore_result(receiver_->Accept(builder.message()));
}

void WindowTreeClientProxy::OnWindowVisibilityChanged(
    uint32_t in_window, bool in_visible) {
  mojo::internal::SerializationContext serialization_context;
  size_t size = sizeof(::ui::mojom::internal::WindowTreeClient_OnWindowVisibilityChanged_Params_Data);
  constexpr uint32_t kFlags = 0;
  mojo::internal::MessageBuilder builder(
      internal::kWindowTreeClient_OnWindowVisibilityChanged_Name, kFlags, size,
      serialization_context.associated_endpoint_count);

  auto params =
      ::ui::mojom::internal::WindowTreeClient_OnWindowVisibilityChanged_Params_Data::New(builder.buffer());
  ALLOW_UNUSED_LOCAL(params);
  params->window = in_window;
  params->visible = in_visible;
  (&serialization_context)->handles.Swap(
      builder.message()->mutable_handles());
  (&serialization_context)->associated_endpoint_handles.swap(
      *builder.message()->mutable_associated_endpoint_handles());
  // This return value may be ignored as false implies the Connector has
  // encountered an error, which will be visible through other means.
  ignore_result(receiver_->Accept(builder.message()));
}

void WindowTreeClientProxy::OnWindowOpacityChanged(
    uint32_t in_window, float in_old_opacity, float in_new_opacity) {
  mojo::internal::SerializationContext serialization_context;
  size_t size = sizeof(::ui::mojom::internal::WindowTreeClient_OnWindowOpacityChanged_Params_Data);
  constexpr uint32_t kFlags = 0;
  mojo::internal::MessageBuilder builder(
      internal::kWindowTreeClient_OnWindowOpacityChanged_Name, kFlags, size,
      serialization_context.associated_endpoint_count);

  auto params =
      ::ui::mojom::internal::WindowTreeClient_OnWindowOpacityChanged_Params_Data::New(builder.buffer());
  ALLOW_UNUSED_LOCAL(params);
  params->window = in_window;
  params->old_opacity = in_old_opacity;
  params->new_opacity = in_new_opacity;
  (&serialization_context)->handles.Swap(
      builder.message()->mutable_handles());
  (&serialization_context)->associated_endpoint_handles.swap(
      *builder.message()->mutable_associated_endpoint_handles());
  // This return value may be ignored as false implies the Connector has
  // encountered an error, which will be visible through other means.
  ignore_result(receiver_->Accept(builder.message()));
}

void WindowTreeClientProxy::OnWindowParentDrawnStateChanged(
    uint32_t in_window, bool in_drawn) {
  mojo::internal::SerializationContext serialization_context;
  size_t size = sizeof(::ui::mojom::internal::WindowTreeClient_OnWindowParentDrawnStateChanged_Params_Data);
  constexpr uint32_t kFlags = 0;
  mojo::internal::MessageBuilder builder(
      internal::kWindowTreeClient_OnWindowParentDrawnStateChanged_Name, kFlags, size,
      serialization_context.associated_endpoint_count);

  auto params =
      ::ui::mojom::internal::WindowTreeClient_OnWindowParentDrawnStateChanged_Params_Data::New(builder.buffer());
  ALLOW_UNUSED_LOCAL(params);
  params->window = in_window;
  params->drawn = in_drawn;
  (&serialization_context)->handles.Swap(
      builder.message()->mutable_handles());
  (&serialization_context)->associated_endpoint_handles.swap(
      *builder.message()->mutable_associated_endpoint_handles());
  // This return value may be ignored as false implies the Connector has
  // encountered an error, which will be visible through other means.
  ignore_result(receiver_->Accept(builder.message()));
}

void WindowTreeClientProxy::OnWindowSharedPropertyChanged(
    uint32_t in_window, const WTF::String& in_name, const WTF::Optional<WTF::Vector<uint8_t>>& in_new_data) {
  mojo::internal::SerializationContext serialization_context;
  size_t size = sizeof(::ui::mojom::internal::WindowTreeClient_OnWindowSharedPropertyChanged_Params_Data);
  size += mojo::internal::PrepareToSerialize<mojo::StringDataView>(
      in_name, &serialization_context);
  size += mojo::internal::PrepareToSerialize<mojo::ArrayDataView<uint8_t>>(
      in_new_data, &serialization_context);
  constexpr uint32_t kFlags = 0;
  mojo::internal::MessageBuilder builder(
      internal::kWindowTreeClient_OnWindowSharedPropertyChanged_Name, kFlags, size,
      serialization_context.associated_endpoint_count);

  auto params =
      ::ui::mojom::internal::WindowTreeClient_OnWindowSharedPropertyChanged_Params_Data::New(builder.buffer());
  ALLOW_UNUSED_LOCAL(params);
  params->window = in_window;
  typename decltype(params->name)::BaseType* name_ptr;
  mojo::internal::Serialize<mojo::StringDataView>(
      in_name, builder.buffer(), &name_ptr, &serialization_context);
  params->name.Set(name_ptr);
  MOJO_INTERNAL_DLOG_SERIALIZATION_WARNING(
      params->name.is_null(),
      mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
      "null name in WindowTreeClient.OnWindowSharedPropertyChanged request");
  typename decltype(params->new_data)::BaseType* new_data_ptr;
  const mojo::internal::ContainerValidateParams new_data_validate_params(
      0, false, nullptr);
  mojo::internal::Serialize<mojo::ArrayDataView<uint8_t>>(
      in_new_data, builder.buffer(), &new_data_ptr, &new_data_validate_params,
      &serialization_context);
  params->new_data.Set(new_data_ptr);
  (&serialization_context)->handles.Swap(
      builder.message()->mutable_handles());
  (&serialization_context)->associated_endpoint_handles.swap(
      *builder.message()->mutable_associated_endpoint_handles());
  // This return value may be ignored as false implies the Connector has
  // encountered an error, which will be visible through other means.
  ignore_result(receiver_->Accept(builder.message()));
}

void WindowTreeClientProxy::OnWindowInputEvent(
    uint32_t in_event_id, uint32_t in_window, int64_t in_display_id, ::ui::mojom::blink::EventPtr in_event, bool in_matches_pointer_watcher) {
  mojo::internal::SerializationContext serialization_context;
  size_t size = sizeof(::ui::mojom::internal::WindowTreeClient_OnWindowInputEvent_Params_Data);
  size += mojo::internal::PrepareToSerialize<::ui::mojom::EventDataView>(
      in_event, &serialization_context);
  constexpr uint32_t kFlags = 0;
  mojo::internal::MessageBuilder builder(
      internal::kWindowTreeClient_OnWindowInputEvent_Name, kFlags, size,
      serialization_context.associated_endpoint_count);

  auto params =
      ::ui::mojom::internal::WindowTreeClient_OnWindowInputEvent_Params_Data::New(builder.buffer());
  ALLOW_UNUSED_LOCAL(params);
  params->event_id = in_event_id;
  params->window = in_window;
  params->display_id = in_display_id;
  typename decltype(params->event)::BaseType* event_ptr;
  mojo::internal::Serialize<::ui::mojom::EventDataView>(
      in_event, builder.buffer(), &event_ptr, &serialization_context);
  params->event.Set(event_ptr);
  MOJO_INTERNAL_DLOG_SERIALIZATION_WARNING(
      params->event.is_null(),
      mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
      "null event in WindowTreeClient.OnWindowInputEvent request");
  params->matches_pointer_watcher = in_matches_pointer_watcher;
  (&serialization_context)->handles.Swap(
      builder.message()->mutable_handles());
  (&serialization_context)->associated_endpoint_handles.swap(
      *builder.message()->mutable_associated_endpoint_handles());
  // This return value may be ignored as false implies the Connector has
  // encountered an error, which will be visible through other means.
  ignore_result(receiver_->Accept(builder.message()));
}

void WindowTreeClientProxy::OnPointerEventObserved(
    ::ui::mojom::blink::EventPtr in_event, uint32_t in_window_id, int64_t in_display_id) {
  mojo::internal::SerializationContext serialization_context;
  size_t size = sizeof(::ui::mojom::internal::WindowTreeClient_OnPointerEventObserved_Params_Data);
  size += mojo::internal::PrepareToSerialize<::ui::mojom::EventDataView>(
      in_event, &serialization_context);
  constexpr uint32_t kFlags = 0;
  mojo::internal::MessageBuilder builder(
      internal::kWindowTreeClient_OnPointerEventObserved_Name, kFlags, size,
      serialization_context.associated_endpoint_count);

  auto params =
      ::ui::mojom::internal::WindowTreeClient_OnPointerEventObserved_Params_Data::New(builder.buffer());
  ALLOW_UNUSED_LOCAL(params);
  typename decltype(params->event)::BaseType* event_ptr;
  mojo::internal::Serialize<::ui::mojom::EventDataView>(
      in_event, builder.buffer(), &event_ptr, &serialization_context);
  params->event.Set(event_ptr);
  MOJO_INTERNAL_DLOG_SERIALIZATION_WARNING(
      params->event.is_null(),
      mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
      "null event in WindowTreeClient.OnPointerEventObserved request");
  params->window_id = in_window_id;
  params->display_id = in_display_id;
  (&serialization_context)->handles.Swap(
      builder.message()->mutable_handles());
  (&serialization_context)->associated_endpoint_handles.swap(
      *builder.message()->mutable_associated_endpoint_handles());
  // This return value may be ignored as false implies the Connector has
  // encountered an error, which will be visible through other means.
  ignore_result(receiver_->Accept(builder.message()));
}

void WindowTreeClientProxy::OnWindowFocused(
    uint32_t in_focused_window_id) {
  mojo::internal::SerializationContext serialization_context;
  size_t size = sizeof(::ui::mojom::internal::WindowTreeClient_OnWindowFocused_Params_Data);
  constexpr uint32_t kFlags = 0;
  mojo::internal::MessageBuilder builder(
      internal::kWindowTreeClient_OnWindowFocused_Name, kFlags, size,
      serialization_context.associated_endpoint_count);

  auto params =
      ::ui::mojom::internal::WindowTreeClient_OnWindowFocused_Params_Data::New(builder.buffer());
  ALLOW_UNUSED_LOCAL(params);
  params->focused_window_id = in_focused_window_id;
  (&serialization_context)->handles.Swap(
      builder.message()->mutable_handles());
  (&serialization_context)->associated_endpoint_handles.swap(
      *builder.message()->mutable_associated_endpoint_handles());
  // This return value may be ignored as false implies the Connector has
  // encountered an error, which will be visible through other means.
  ignore_result(receiver_->Accept(builder.message()));
}

void WindowTreeClientProxy::OnWindowCursorChanged(
    uint32_t in_window_id, ::ui::mojom::blink::CursorDataPtr in_cursor) {
  mojo::internal::SerializationContext serialization_context;
  size_t size = sizeof(::ui::mojom::internal::WindowTreeClient_OnWindowCursorChanged_Params_Data);
  size += mojo::internal::PrepareToSerialize<::ui::mojom::CursorDataDataView>(
      in_cursor, &serialization_context);
  constexpr uint32_t kFlags = 0;
  mojo::internal::MessageBuilder builder(
      internal::kWindowTreeClient_OnWindowCursorChanged_Name, kFlags, size,
      serialization_context.associated_endpoint_count);

  auto params =
      ::ui::mojom::internal::WindowTreeClient_OnWindowCursorChanged_Params_Data::New(builder.buffer());
  ALLOW_UNUSED_LOCAL(params);
  params->window_id = in_window_id;
  typename decltype(params->cursor)::BaseType* cursor_ptr;
  mojo::internal::Serialize<::ui::mojom::CursorDataDataView>(
      in_cursor, builder.buffer(), &cursor_ptr, &serialization_context);
  params->cursor.Set(cursor_ptr);
  MOJO_INTERNAL_DLOG_SERIALIZATION_WARNING(
      params->cursor.is_null(),
      mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
      "null cursor in WindowTreeClient.OnWindowCursorChanged request");
  (&serialization_context)->handles.Swap(
      builder.message()->mutable_handles());
  (&serialization_context)->associated_endpoint_handles.swap(
      *builder.message()->mutable_associated_endpoint_handles());
  // This return value may be ignored as false implies the Connector has
  // encountered an error, which will be visible through other means.
  ignore_result(receiver_->Accept(builder.message()));
}

void WindowTreeClientProxy::OnWindowSurfaceChanged(
    uint32_t in_window_id, const cc::SurfaceInfo& in_surface_info) {
  mojo::internal::SerializationContext serialization_context;
  size_t size = sizeof(::ui::mojom::internal::WindowTreeClient_OnWindowSurfaceChanged_Params_Data);
  size += mojo::internal::PrepareToSerialize<::cc::mojom::SurfaceInfoDataView>(
      in_surface_info, &serialization_context);
  constexpr uint32_t kFlags = 0;
  mojo::internal::MessageBuilder builder(
      internal::kWindowTreeClient_OnWindowSurfaceChanged_Name, kFlags, size,
      serialization_context.associated_endpoint_count);

  auto params =
      ::ui::mojom::internal::WindowTreeClient_OnWindowSurfaceChanged_Params_Data::New(builder.buffer());
  ALLOW_UNUSED_LOCAL(params);
  params->window_id = in_window_id;
  typename decltype(params->surface_info)::BaseType* surface_info_ptr;
  mojo::internal::Serialize<::cc::mojom::SurfaceInfoDataView>(
      in_surface_info, builder.buffer(), &surface_info_ptr, &serialization_context);
  params->surface_info.Set(surface_info_ptr);
  MOJO_INTERNAL_DLOG_SERIALIZATION_WARNING(
      params->surface_info.is_null(),
      mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
      "null surface_info in WindowTreeClient.OnWindowSurfaceChanged request");
  (&serialization_context)->handles.Swap(
      builder.message()->mutable_handles());
  (&serialization_context)->associated_endpoint_handles.swap(
      *builder.message()->mutable_associated_endpoint_handles());
  // This return value may be ignored as false implies the Connector has
  // encountered an error, which will be visible through other means.
  ignore_result(receiver_->Accept(builder.message()));
}

void WindowTreeClientProxy::OnDragDropStart(
    const WTF::HashMap<WTF::String, WTF::Vector<uint8_t>>& in_drag_data) {
  mojo::internal::SerializationContext serialization_context;
  size_t size = sizeof(::ui::mojom::internal::WindowTreeClient_OnDragDropStart_Params_Data);
  size += mojo::internal::PrepareToSerialize<mojo::MapDataView<mojo::StringDataView, mojo::ArrayDataView<uint8_t>>>(
      in_drag_data, &serialization_context);
  constexpr uint32_t kFlags = 0;
  mojo::internal::MessageBuilder builder(
      internal::kWindowTreeClient_OnDragDropStart_Name, kFlags, size,
      serialization_context.associated_endpoint_count);

  auto params =
      ::ui::mojom::internal::WindowTreeClient_OnDragDropStart_Params_Data::New(builder.buffer());
  ALLOW_UNUSED_LOCAL(params);
  typename decltype(params->drag_data)::BaseType* drag_data_ptr;
  const mojo::internal::ContainerValidateParams drag_data_validate_params(
      new mojo::internal::ContainerValidateParams(0, false, new mojo::internal::ContainerValidateParams(0, false, nullptr)), new mojo::internal::ContainerValidateParams(0, false, new mojo::internal::ContainerValidateParams(0, false, nullptr)));
  mojo::internal::Serialize<mojo::MapDataView<mojo::StringDataView, mojo::ArrayDataView<uint8_t>>>(
      in_drag_data, builder.buffer(), &drag_data_ptr, &drag_data_validate_params,
      &serialization_context);
  params->drag_data.Set(drag_data_ptr);
  MOJO_INTERNAL_DLOG_SERIALIZATION_WARNING(
      params->drag_data.is_null(),
      mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
      "null drag_data in WindowTreeClient.OnDragDropStart request");
  (&serialization_context)->handles.Swap(
      builder.message()->mutable_handles());
  (&serialization_context)->associated_endpoint_handles.swap(
      *builder.message()->mutable_associated_endpoint_handles());
  // This return value may be ignored as false implies the Connector has
  // encountered an error, which will be visible through other means.
  ignore_result(receiver_->Accept(builder.message()));
}

void WindowTreeClientProxy::OnDragEnter(
    uint32_t in_window, uint32_t in_key_state, ::gfx::mojom::blink::PointPtr in_screen_position, uint32_t in_effect_bitmask, const OnDragEnterCallback& callback) {
  mojo::internal::SerializationContext serialization_context;
  size_t size = sizeof(::ui::mojom::internal::WindowTreeClient_OnDragEnter_Params_Data);
  size += mojo::internal::PrepareToSerialize<::gfx::mojom::PointDataView>(
      in_screen_position, &serialization_context);
  constexpr uint32_t kFlags = mojo::Message::kFlagExpectsResponse;
  mojo::internal::MessageBuilder builder(
      internal::kWindowTreeClient_OnDragEnter_Name, kFlags, size,
      serialization_context.associated_endpoint_count);

  auto params =
      ::ui::mojom::internal::WindowTreeClient_OnDragEnter_Params_Data::New(builder.buffer());
  ALLOW_UNUSED_LOCAL(params);
  params->window = in_window;
  params->key_state = in_key_state;
  typename decltype(params->screen_position)::BaseType* screen_position_ptr;
  mojo::internal::Serialize<::gfx::mojom::PointDataView>(
      in_screen_position, builder.buffer(), &screen_position_ptr, &serialization_context);
  params->screen_position.Set(screen_position_ptr);
  MOJO_INTERNAL_DLOG_SERIALIZATION_WARNING(
      params->screen_position.is_null(),
      mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
      "null screen_position in WindowTreeClient.OnDragEnter request");
  params->effect_bitmask = in_effect_bitmask;
  (&serialization_context)->handles.Swap(
      builder.message()->mutable_handles());
  (&serialization_context)->associated_endpoint_handles.swap(
      *builder.message()->mutable_associated_endpoint_handles());
  std::unique_ptr<mojo::MessageReceiver> responder(
      new WindowTreeClient_OnDragEnter_ForwardToCallback(
          std::move(callback)));
  ignore_result(receiver_->AcceptWithResponder(builder.message(),
                                               std::move(responder)));
}

void WindowTreeClientProxy::OnDragOver(
    uint32_t in_window, uint32_t in_key_state, ::gfx::mojom::blink::PointPtr in_screen_position, uint32_t in_effect_bitmask, const OnDragOverCallback& callback) {
  mojo::internal::SerializationContext serialization_context;
  size_t size = sizeof(::ui::mojom::internal::WindowTreeClient_OnDragOver_Params_Data);
  size += mojo::internal::PrepareToSerialize<::gfx::mojom::PointDataView>(
      in_screen_position, &serialization_context);
  constexpr uint32_t kFlags = mojo::Message::kFlagExpectsResponse;
  mojo::internal::MessageBuilder builder(
      internal::kWindowTreeClient_OnDragOver_Name, kFlags, size,
      serialization_context.associated_endpoint_count);

  auto params =
      ::ui::mojom::internal::WindowTreeClient_OnDragOver_Params_Data::New(builder.buffer());
  ALLOW_UNUSED_LOCAL(params);
  params->window = in_window;
  params->key_state = in_key_state;
  typename decltype(params->screen_position)::BaseType* screen_position_ptr;
  mojo::internal::Serialize<::gfx::mojom::PointDataView>(
      in_screen_position, builder.buffer(), &screen_position_ptr, &serialization_context);
  params->screen_position.Set(screen_position_ptr);
  MOJO_INTERNAL_DLOG_SERIALIZATION_WARNING(
      params->screen_position.is_null(),
      mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
      "null screen_position in WindowTreeClient.OnDragOver request");
  params->effect_bitmask = in_effect_bitmask;
  (&serialization_context)->handles.Swap(
      builder.message()->mutable_handles());
  (&serialization_context)->associated_endpoint_handles.swap(
      *builder.message()->mutable_associated_endpoint_handles());
  std::unique_ptr<mojo::MessageReceiver> responder(
      new WindowTreeClient_OnDragOver_ForwardToCallback(
          std::move(callback)));
  ignore_result(receiver_->AcceptWithResponder(builder.message(),
                                               std::move(responder)));
}

void WindowTreeClientProxy::OnDragLeave(
    uint32_t in_window) {
  mojo::internal::SerializationContext serialization_context;
  size_t size = sizeof(::ui::mojom::internal::WindowTreeClient_OnDragLeave_Params_Data);
  constexpr uint32_t kFlags = 0;
  mojo::internal::MessageBuilder builder(
      internal::kWindowTreeClient_OnDragLeave_Name, kFlags, size,
      serialization_context.associated_endpoint_count);

  auto params =
      ::ui::mojom::internal::WindowTreeClient_OnDragLeave_Params_Data::New(builder.buffer());
  ALLOW_UNUSED_LOCAL(params);
  params->window = in_window;
  (&serialization_context)->handles.Swap(
      builder.message()->mutable_handles());
  (&serialization_context)->associated_endpoint_handles.swap(
      *builder.message()->mutable_associated_endpoint_handles());
  // This return value may be ignored as false implies the Connector has
  // encountered an error, which will be visible through other means.
  ignore_result(receiver_->Accept(builder.message()));
}

void WindowTreeClientProxy::OnCompleteDrop(
    uint32_t in_window, uint32_t in_key_state, ::gfx::mojom::blink::PointPtr in_screen_position, uint32_t in_effect_bitmask, const OnCompleteDropCallback& callback) {
  mojo::internal::SerializationContext serialization_context;
  size_t size = sizeof(::ui::mojom::internal::WindowTreeClient_OnCompleteDrop_Params_Data);
  size += mojo::internal::PrepareToSerialize<::gfx::mojom::PointDataView>(
      in_screen_position, &serialization_context);
  constexpr uint32_t kFlags = mojo::Message::kFlagExpectsResponse;
  mojo::internal::MessageBuilder builder(
      internal::kWindowTreeClient_OnCompleteDrop_Name, kFlags, size,
      serialization_context.associated_endpoint_count);

  auto params =
      ::ui::mojom::internal::WindowTreeClient_OnCompleteDrop_Params_Data::New(builder.buffer());
  ALLOW_UNUSED_LOCAL(params);
  params->window = in_window;
  params->key_state = in_key_state;
  typename decltype(params->screen_position)::BaseType* screen_position_ptr;
  mojo::internal::Serialize<::gfx::mojom::PointDataView>(
      in_screen_position, builder.buffer(), &screen_position_ptr, &serialization_context);
  params->screen_position.Set(screen_position_ptr);
  MOJO_INTERNAL_DLOG_SERIALIZATION_WARNING(
      params->screen_position.is_null(),
      mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
      "null screen_position in WindowTreeClient.OnCompleteDrop request");
  params->effect_bitmask = in_effect_bitmask;
  (&serialization_context)->handles.Swap(
      builder.message()->mutable_handles());
  (&serialization_context)->associated_endpoint_handles.swap(
      *builder.message()->mutable_associated_endpoint_handles());
  std::unique_ptr<mojo::MessageReceiver> responder(
      new WindowTreeClient_OnCompleteDrop_ForwardToCallback(
          std::move(callback)));
  ignore_result(receiver_->AcceptWithResponder(builder.message(),
                                               std::move(responder)));
}

void WindowTreeClientProxy::OnPerformDragDropCompleted(
    uint32_t in_window, bool in_success, uint32_t in_action_taken) {
  mojo::internal::SerializationContext serialization_context;
  size_t size = sizeof(::ui::mojom::internal::WindowTreeClient_OnPerformDragDropCompleted_Params_Data);
  constexpr uint32_t kFlags = 0;
  mojo::internal::MessageBuilder builder(
      internal::kWindowTreeClient_OnPerformDragDropCompleted_Name, kFlags, size,
      serialization_context.associated_endpoint_count);

  auto params =
      ::ui::mojom::internal::WindowTreeClient_OnPerformDragDropCompleted_Params_Data::New(builder.buffer());
  ALLOW_UNUSED_LOCAL(params);
  params->window = in_window;
  params->success = in_success;
  params->action_taken = in_action_taken;
  (&serialization_context)->handles.Swap(
      builder.message()->mutable_handles());
  (&serialization_context)->associated_endpoint_handles.swap(
      *builder.message()->mutable_associated_endpoint_handles());
  // This return value may be ignored as false implies the Connector has
  // encountered an error, which will be visible through other means.
  ignore_result(receiver_->Accept(builder.message()));
}

void WindowTreeClientProxy::OnDragDropDone(
    ) {
  mojo::internal::SerializationContext serialization_context;
  size_t size = sizeof(::ui::mojom::internal::WindowTreeClient_OnDragDropDone_Params_Data);
  constexpr uint32_t kFlags = 0;
  mojo::internal::MessageBuilder builder(
      internal::kWindowTreeClient_OnDragDropDone_Name, kFlags, size,
      serialization_context.associated_endpoint_count);

  auto params =
      ::ui::mojom::internal::WindowTreeClient_OnDragDropDone_Params_Data::New(builder.buffer());
  ALLOW_UNUSED_LOCAL(params);
  (&serialization_context)->handles.Swap(
      builder.message()->mutable_handles());
  (&serialization_context)->associated_endpoint_handles.swap(
      *builder.message()->mutable_associated_endpoint_handles());
  // This return value may be ignored as false implies the Connector has
  // encountered an error, which will be visible through other means.
  ignore_result(receiver_->Accept(builder.message()));
}

void WindowTreeClientProxy::OnChangeCompleted(
    uint32_t in_change_id, bool in_success) {
  mojo::internal::SerializationContext serialization_context;
  size_t size = sizeof(::ui::mojom::internal::WindowTreeClient_OnChangeCompleted_Params_Data);
  constexpr uint32_t kFlags = 0;
  mojo::internal::MessageBuilder builder(
      internal::kWindowTreeClient_OnChangeCompleted_Name, kFlags, size,
      serialization_context.associated_endpoint_count);

  auto params =
      ::ui::mojom::internal::WindowTreeClient_OnChangeCompleted_Params_Data::New(builder.buffer());
  ALLOW_UNUSED_LOCAL(params);
  params->change_id = in_change_id;
  params->success = in_success;
  (&serialization_context)->handles.Swap(
      builder.message()->mutable_handles());
  (&serialization_context)->associated_endpoint_handles.swap(
      *builder.message()->mutable_associated_endpoint_handles());
  // This return value may be ignored as false implies the Connector has
  // encountered an error, which will be visible through other means.
  ignore_result(receiver_->Accept(builder.message()));
}

void WindowTreeClientProxy::RequestClose(
    uint32_t in_window_id) {
  mojo::internal::SerializationContext serialization_context;
  size_t size = sizeof(::ui::mojom::internal::WindowTreeClient_RequestClose_Params_Data);
  constexpr uint32_t kFlags = 0;
  mojo::internal::MessageBuilder builder(
      internal::kWindowTreeClient_RequestClose_Name, kFlags, size,
      serialization_context.associated_endpoint_count);

  auto params =
      ::ui::mojom::internal::WindowTreeClient_RequestClose_Params_Data::New(builder.buffer());
  ALLOW_UNUSED_LOCAL(params);
  params->window_id = in_window_id;
  (&serialization_context)->handles.Swap(
      builder.message()->mutable_handles());
  (&serialization_context)->associated_endpoint_handles.swap(
      *builder.message()->mutable_associated_endpoint_handles());
  // This return value may be ignored as false implies the Connector has
  // encountered an error, which will be visible through other means.
  ignore_result(receiver_->Accept(builder.message()));
}

void WindowTreeClientProxy::GetWindowManager(
    ::ui::mojom::blink::WindowManagerAssociatedRequest in_internal) {
  mojo::internal::SerializationContext serialization_context;
  size_t size = sizeof(::ui::mojom::internal::WindowTreeClient_GetWindowManager_Params_Data);
  size += mojo::internal::PrepareToSerialize<::ui::mojom::WindowManagerAssociatedRequestDataView>(
      in_internal, &serialization_context);
  constexpr uint32_t kFlags = 0;
  mojo::internal::MessageBuilder builder(
      internal::kWindowTreeClient_GetWindowManager_Name, kFlags, size,
      serialization_context.associated_endpoint_count);

  auto params =
      ::ui::mojom::internal::WindowTreeClient_GetWindowManager_Params_Data::New(builder.buffer());
  ALLOW_UNUSED_LOCAL(params);
  mojo::internal::Serialize<::ui::mojom::WindowManagerAssociatedRequestDataView>(
      in_internal, &params->internal, &serialization_context);
  MOJO_INTERNAL_DLOG_SERIALIZATION_WARNING(
      !mojo::internal::IsHandleOrInterfaceValid(params->internal),
      mojo::internal::VALIDATION_ERROR_UNEXPECTED_INVALID_INTERFACE_ID,
      "invalid internal in WindowTreeClient.GetWindowManager request");
  (&serialization_context)->handles.Swap(
      builder.message()->mutable_handles());
  (&serialization_context)->associated_endpoint_handles.swap(
      *builder.message()->mutable_associated_endpoint_handles());
  // This return value may be ignored as false implies the Connector has
  // encountered an error, which will be visible through other means.
  ignore_result(receiver_->Accept(builder.message()));
}
class WindowTreeClient_OnDragEnter_ProxyToResponder {
 public:
  static WindowTreeClient::OnDragEnterCallback CreateCallback(
      uint64_t request_id,
      bool is_sync,
      std::unique_ptr<mojo::MessageReceiverWithStatus> responder) {
    std::unique_ptr<WindowTreeClient_OnDragEnter_ProxyToResponder> proxy(
        new WindowTreeClient_OnDragEnter_ProxyToResponder(
            request_id, is_sync, std::move(responder)));
    return base::Bind(&WindowTreeClient_OnDragEnter_ProxyToResponder::Run,
                      base::Passed(&proxy));
  }

  ~WindowTreeClient_OnDragEnter_ProxyToResponder() {
#if DCHECK_IS_ON()
    if (responder_) {
      // Is the Service destroying the callback without running it
      // and without first closing the pipe?
      responder_->DCheckInvalid("The callback passed to "
          "WindowTreeClient::OnDragEnter() was never run.");
    }
#endif
    // If the Callback was dropped then deleting the responder will close
    // the pipe so the calling application knows to stop waiting for a reply.
    responder_ = nullptr;
  }

 private:
  WindowTreeClient_OnDragEnter_ProxyToResponder(
      uint64_t request_id,
      bool is_sync,
      std::unique_ptr<mojo::MessageReceiverWithStatus> responder)
      : request_id_(request_id),
        is_sync_(is_sync),
        responder_(std::move(responder)) {
  }

  void Run(
      uint32_t in_supported_op_bitmask);

  uint64_t request_id_;
  bool is_sync_;
  std::unique_ptr<mojo::MessageReceiverWithStatus> responder_;

  DISALLOW_COPY_AND_ASSIGN(WindowTreeClient_OnDragEnter_ProxyToResponder);
};

void WindowTreeClient_OnDragEnter_ProxyToResponder::Run(
    uint32_t in_supported_op_bitmask) {
  mojo::internal::SerializationContext serialization_context;
  size_t size = sizeof(::ui::mojom::internal::WindowTreeClient_OnDragEnter_ResponseParams_Data);

  uint32_t flags = (is_sync_ ? mojo::Message::kFlagIsSync : 0) |
                   mojo::Message::kFlagIsResponse;
  mojo::internal::MessageBuilder builder(
      internal::kWindowTreeClient_OnDragEnter_Name, flags, size,
      serialization_context.associated_endpoint_count);
  builder.message()->set_request_id(request_id_);

  auto params =
      ::ui::mojom::internal::WindowTreeClient_OnDragEnter_ResponseParams_Data::New(builder.buffer());
  ALLOW_UNUSED_LOCAL(params);
  params->supported_op_bitmask = in_supported_op_bitmask;
  (&serialization_context)->handles.Swap(
      builder.message()->mutable_handles());
  (&serialization_context)->associated_endpoint_handles.swap(
      *builder.message()->mutable_associated_endpoint_handles());
  ignore_result(responder_->Accept(builder.message()));
  // TODO(darin): Accept() returning false indicates a malformed message, and
  // that may be good reason to close the connection. However, we don't have a
  // way to do that from here. We should add a way.
  responder_ = nullptr;
}
class WindowTreeClient_OnDragOver_ProxyToResponder {
 public:
  static WindowTreeClient::OnDragOverCallback CreateCallback(
      uint64_t request_id,
      bool is_sync,
      std::unique_ptr<mojo::MessageReceiverWithStatus> responder) {
    std::unique_ptr<WindowTreeClient_OnDragOver_ProxyToResponder> proxy(
        new WindowTreeClient_OnDragOver_ProxyToResponder(
            request_id, is_sync, std::move(responder)));
    return base::Bind(&WindowTreeClient_OnDragOver_ProxyToResponder::Run,
                      base::Passed(&proxy));
  }

  ~WindowTreeClient_OnDragOver_ProxyToResponder() {
#if DCHECK_IS_ON()
    if (responder_) {
      // Is the Service destroying the callback without running it
      // and without first closing the pipe?
      responder_->DCheckInvalid("The callback passed to "
          "WindowTreeClient::OnDragOver() was never run.");
    }
#endif
    // If the Callback was dropped then deleting the responder will close
    // the pipe so the calling application knows to stop waiting for a reply.
    responder_ = nullptr;
  }

 private:
  WindowTreeClient_OnDragOver_ProxyToResponder(
      uint64_t request_id,
      bool is_sync,
      std::unique_ptr<mojo::MessageReceiverWithStatus> responder)
      : request_id_(request_id),
        is_sync_(is_sync),
        responder_(std::move(responder)) {
  }

  void Run(
      uint32_t in_supported_op_bitmask);

  uint64_t request_id_;
  bool is_sync_;
  std::unique_ptr<mojo::MessageReceiverWithStatus> responder_;

  DISALLOW_COPY_AND_ASSIGN(WindowTreeClient_OnDragOver_ProxyToResponder);
};

void WindowTreeClient_OnDragOver_ProxyToResponder::Run(
    uint32_t in_supported_op_bitmask) {
  mojo::internal::SerializationContext serialization_context;
  size_t size = sizeof(::ui::mojom::internal::WindowTreeClient_OnDragOver_ResponseParams_Data);

  uint32_t flags = (is_sync_ ? mojo::Message::kFlagIsSync : 0) |
                   mojo::Message::kFlagIsResponse;
  mojo::internal::MessageBuilder builder(
      internal::kWindowTreeClient_OnDragOver_Name, flags, size,
      serialization_context.associated_endpoint_count);
  builder.message()->set_request_id(request_id_);

  auto params =
      ::ui::mojom::internal::WindowTreeClient_OnDragOver_ResponseParams_Data::New(builder.buffer());
  ALLOW_UNUSED_LOCAL(params);
  params->supported_op_bitmask = in_supported_op_bitmask;
  (&serialization_context)->handles.Swap(
      builder.message()->mutable_handles());
  (&serialization_context)->associated_endpoint_handles.swap(
      *builder.message()->mutable_associated_endpoint_handles());
  ignore_result(responder_->Accept(builder.message()));
  // TODO(darin): Accept() returning false indicates a malformed message, and
  // that may be good reason to close the connection. However, we don't have a
  // way to do that from here. We should add a way.
  responder_ = nullptr;
}
class WindowTreeClient_OnCompleteDrop_ProxyToResponder {
 public:
  static WindowTreeClient::OnCompleteDropCallback CreateCallback(
      uint64_t request_id,
      bool is_sync,
      std::unique_ptr<mojo::MessageReceiverWithStatus> responder) {
    std::unique_ptr<WindowTreeClient_OnCompleteDrop_ProxyToResponder> proxy(
        new WindowTreeClient_OnCompleteDrop_ProxyToResponder(
            request_id, is_sync, std::move(responder)));
    return base::Bind(&WindowTreeClient_OnCompleteDrop_ProxyToResponder::Run,
                      base::Passed(&proxy));
  }

  ~WindowTreeClient_OnCompleteDrop_ProxyToResponder() {
#if DCHECK_IS_ON()
    if (responder_) {
      // Is the Service destroying the callback without running it
      // and without first closing the pipe?
      responder_->DCheckInvalid("The callback passed to "
          "WindowTreeClient::OnCompleteDrop() was never run.");
    }
#endif
    // If the Callback was dropped then deleting the responder will close
    // the pipe so the calling application knows to stop waiting for a reply.
    responder_ = nullptr;
  }

 private:
  WindowTreeClient_OnCompleteDrop_ProxyToResponder(
      uint64_t request_id,
      bool is_sync,
      std::unique_ptr<mojo::MessageReceiverWithStatus> responder)
      : request_id_(request_id),
        is_sync_(is_sync),
        responder_(std::move(responder)) {
  }

  void Run(
      uint32_t in_action_taken);

  uint64_t request_id_;
  bool is_sync_;
  std::unique_ptr<mojo::MessageReceiverWithStatus> responder_;

  DISALLOW_COPY_AND_ASSIGN(WindowTreeClient_OnCompleteDrop_ProxyToResponder);
};

void WindowTreeClient_OnCompleteDrop_ProxyToResponder::Run(
    uint32_t in_action_taken) {
  mojo::internal::SerializationContext serialization_context;
  size_t size = sizeof(::ui::mojom::internal::WindowTreeClient_OnCompleteDrop_ResponseParams_Data);

  uint32_t flags = (is_sync_ ? mojo::Message::kFlagIsSync : 0) |
                   mojo::Message::kFlagIsResponse;
  mojo::internal::MessageBuilder builder(
      internal::kWindowTreeClient_OnCompleteDrop_Name, flags, size,
      serialization_context.associated_endpoint_count);
  builder.message()->set_request_id(request_id_);

  auto params =
      ::ui::mojom::internal::WindowTreeClient_OnCompleteDrop_ResponseParams_Data::New(builder.buffer());
  ALLOW_UNUSED_LOCAL(params);
  params->action_taken = in_action_taken;
  (&serialization_context)->handles.Swap(
      builder.message()->mutable_handles());
  (&serialization_context)->associated_endpoint_handles.swap(
      *builder.message()->mutable_associated_endpoint_handles());
  ignore_result(responder_->Accept(builder.message()));
  // TODO(darin): Accept() returning false indicates a malformed message, and
  // that may be good reason to close the connection. However, we don't have a
  // way to do that from here. We should add a way.
  responder_ = nullptr;
}

// static
bool WindowTreeClientStubDispatch::Accept(
    WindowTreeClient* impl,
    mojo::Message* message) {
  switch (message->header()->name) {
    case internal::kWindowTreeClient_OnEmbed_Name: {
      internal::WindowTreeClient_OnEmbed_Params_Data* params =
          reinterpret_cast<internal::WindowTreeClient_OnEmbed_Params_Data*>(
              message->mutable_payload());
      
      mojo::internal::SerializationContext serialization_context;
      serialization_context.handles.Swap((message)->mutable_handles());
      serialization_context.associated_endpoint_handles.swap(
          *(message)->mutable_associated_endpoint_handles());
      bool success = true;
      uint16_t p_connection_id{};
      ::ui::mojom::blink::WindowDataPtr p_root{};
      WindowTreePtr p_tree{};
      int64_t p_display_id{};
      uint32_t p_focused_window{};
      bool p_parent_drawn{};
      cc::FrameSinkId p_frame_sink_id{};
      WTF::Optional<cc::LocalSurfaceId> p_local_surface_id{};
      WindowTreeClient_OnEmbed_ParamsDataView input_data_view(params, &serialization_context);
      
      p_connection_id = input_data_view.connection_id();
      if (!input_data_view.ReadRoot(&p_root))
        success = false;
      p_tree =
          input_data_view.TakeTree<decltype(p_tree)>();
      p_display_id = input_data_view.display_id();
      p_focused_window = input_data_view.focused_window();
      p_parent_drawn = input_data_view.parent_drawn();
      if (!input_data_view.ReadFrameSinkId(&p_frame_sink_id))
        success = false;
      if (!input_data_view.ReadLocalSurfaceId(&p_local_surface_id))
        success = false;
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            "WindowTreeClient::OnEmbed deserializer");
        return false;
      }
      // A null |impl| means no implementation was bound.
      assert(impl);
      TRACE_EVENT0("mojom", "WindowTreeClient::OnEmbed");
      mojo::internal::MessageDispatchContext context(message);
      impl->OnEmbed(
std::move(p_connection_id), 
std::move(p_root), 
std::move(p_tree), 
std::move(p_display_id), 
std::move(p_focused_window), 
std::move(p_parent_drawn), 
std::move(p_frame_sink_id), 
std::move(p_local_surface_id));
      return true;
    }
    case internal::kWindowTreeClient_OnEmbeddedAppDisconnected_Name: {
      internal::WindowTreeClient_OnEmbeddedAppDisconnected_Params_Data* params =
          reinterpret_cast<internal::WindowTreeClient_OnEmbeddedAppDisconnected_Params_Data*>(
              message->mutable_payload());
      
      mojo::internal::SerializationContext serialization_context;
      serialization_context.handles.Swap((message)->mutable_handles());
      serialization_context.associated_endpoint_handles.swap(
          *(message)->mutable_associated_endpoint_handles());
      bool success = true;
      uint32_t p_window{};
      WindowTreeClient_OnEmbeddedAppDisconnected_ParamsDataView input_data_view(params, &serialization_context);
      
      p_window = input_data_view.window();
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            "WindowTreeClient::OnEmbeddedAppDisconnected deserializer");
        return false;
      }
      // A null |impl| means no implementation was bound.
      assert(impl);
      TRACE_EVENT0("mojom", "WindowTreeClient::OnEmbeddedAppDisconnected");
      mojo::internal::MessageDispatchContext context(message);
      impl->OnEmbeddedAppDisconnected(
std::move(p_window));
      return true;
    }
    case internal::kWindowTreeClient_OnUnembed_Name: {
      internal::WindowTreeClient_OnUnembed_Params_Data* params =
          reinterpret_cast<internal::WindowTreeClient_OnUnembed_Params_Data*>(
              message->mutable_payload());
      
      mojo::internal::SerializationContext serialization_context;
      serialization_context.handles.Swap((message)->mutable_handles());
      serialization_context.associated_endpoint_handles.swap(
          *(message)->mutable_associated_endpoint_handles());
      bool success = true;
      uint32_t p_window{};
      WindowTreeClient_OnUnembed_ParamsDataView input_data_view(params, &serialization_context);
      
      p_window = input_data_view.window();
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            "WindowTreeClient::OnUnembed deserializer");
        return false;
      }
      // A null |impl| means no implementation was bound.
      assert(impl);
      TRACE_EVENT0("mojom", "WindowTreeClient::OnUnembed");
      mojo::internal::MessageDispatchContext context(message);
      impl->OnUnembed(
std::move(p_window));
      return true;
    }
    case internal::kWindowTreeClient_OnCaptureChanged_Name: {
      internal::WindowTreeClient_OnCaptureChanged_Params_Data* params =
          reinterpret_cast<internal::WindowTreeClient_OnCaptureChanged_Params_Data*>(
              message->mutable_payload());
      
      mojo::internal::SerializationContext serialization_context;
      serialization_context.handles.Swap((message)->mutable_handles());
      serialization_context.associated_endpoint_handles.swap(
          *(message)->mutable_associated_endpoint_handles());
      bool success = true;
      uint32_t p_new_capture{};
      uint32_t p_old_capture{};
      WindowTreeClient_OnCaptureChanged_ParamsDataView input_data_view(params, &serialization_context);
      
      p_new_capture = input_data_view.new_capture();
      p_old_capture = input_data_view.old_capture();
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            "WindowTreeClient::OnCaptureChanged deserializer");
        return false;
      }
      // A null |impl| means no implementation was bound.
      assert(impl);
      TRACE_EVENT0("mojom", "WindowTreeClient::OnCaptureChanged");
      mojo::internal::MessageDispatchContext context(message);
      impl->OnCaptureChanged(
std::move(p_new_capture), 
std::move(p_old_capture));
      return true;
    }
    case internal::kWindowTreeClient_OnFrameSinkIdAllocated_Name: {
      internal::WindowTreeClient_OnFrameSinkIdAllocated_Params_Data* params =
          reinterpret_cast<internal::WindowTreeClient_OnFrameSinkIdAllocated_Params_Data*>(
              message->mutable_payload());
      
      mojo::internal::SerializationContext serialization_context;
      serialization_context.handles.Swap((message)->mutable_handles());
      serialization_context.associated_endpoint_handles.swap(
          *(message)->mutable_associated_endpoint_handles());
      bool success = true;
      uint32_t p_window{};
      cc::FrameSinkId p_frame_sink_id{};
      WindowTreeClient_OnFrameSinkIdAllocated_ParamsDataView input_data_view(params, &serialization_context);
      
      p_window = input_data_view.window();
      if (!input_data_view.ReadFrameSinkId(&p_frame_sink_id))
        success = false;
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            "WindowTreeClient::OnFrameSinkIdAllocated deserializer");
        return false;
      }
      // A null |impl| means no implementation was bound.
      assert(impl);
      TRACE_EVENT0("mojom", "WindowTreeClient::OnFrameSinkIdAllocated");
      mojo::internal::MessageDispatchContext context(message);
      impl->OnFrameSinkIdAllocated(
std::move(p_window), 
std::move(p_frame_sink_id));
      return true;
    }
    case internal::kWindowTreeClient_OnTopLevelCreated_Name: {
      internal::WindowTreeClient_OnTopLevelCreated_Params_Data* params =
          reinterpret_cast<internal::WindowTreeClient_OnTopLevelCreated_Params_Data*>(
              message->mutable_payload());
      
      mojo::internal::SerializationContext serialization_context;
      serialization_context.handles.Swap((message)->mutable_handles());
      serialization_context.associated_endpoint_handles.swap(
          *(message)->mutable_associated_endpoint_handles());
      bool success = true;
      uint32_t p_change_id{};
      ::ui::mojom::blink::WindowDataPtr p_data{};
      int64_t p_display_id{};
      bool p_parent_drawn{};
      cc::FrameSinkId p_frame_sink_id{};
      WTF::Optional<cc::LocalSurfaceId> p_local_surface_id{};
      WindowTreeClient_OnTopLevelCreated_ParamsDataView input_data_view(params, &serialization_context);
      
      p_change_id = input_data_view.change_id();
      if (!input_data_view.ReadData(&p_data))
        success = false;
      p_display_id = input_data_view.display_id();
      p_parent_drawn = input_data_view.parent_drawn();
      if (!input_data_view.ReadFrameSinkId(&p_frame_sink_id))
        success = false;
      if (!input_data_view.ReadLocalSurfaceId(&p_local_surface_id))
        success = false;
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            "WindowTreeClient::OnTopLevelCreated deserializer");
        return false;
      }
      // A null |impl| means no implementation was bound.
      assert(impl);
      TRACE_EVENT0("mojom", "WindowTreeClient::OnTopLevelCreated");
      mojo::internal::MessageDispatchContext context(message);
      impl->OnTopLevelCreated(
std::move(p_change_id), 
std::move(p_data), 
std::move(p_display_id), 
std::move(p_parent_drawn), 
std::move(p_frame_sink_id), 
std::move(p_local_surface_id));
      return true;
    }
    case internal::kWindowTreeClient_OnWindowBoundsChanged_Name: {
      internal::WindowTreeClient_OnWindowBoundsChanged_Params_Data* params =
          reinterpret_cast<internal::WindowTreeClient_OnWindowBoundsChanged_Params_Data*>(
              message->mutable_payload());
      
      mojo::internal::SerializationContext serialization_context;
      serialization_context.handles.Swap((message)->mutable_handles());
      serialization_context.associated_endpoint_handles.swap(
          *(message)->mutable_associated_endpoint_handles());
      bool success = true;
      uint32_t p_window{};
      ::gfx::mojom::blink::RectPtr p_old_bounds{};
      ::gfx::mojom::blink::RectPtr p_new_bounds{};
      WTF::Optional<cc::LocalSurfaceId> p_local_surface_id{};
      WindowTreeClient_OnWindowBoundsChanged_ParamsDataView input_data_view(params, &serialization_context);
      
      p_window = input_data_view.window();
      if (!input_data_view.ReadOldBounds(&p_old_bounds))
        success = false;
      if (!input_data_view.ReadNewBounds(&p_new_bounds))
        success = false;
      if (!input_data_view.ReadLocalSurfaceId(&p_local_surface_id))
        success = false;
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            "WindowTreeClient::OnWindowBoundsChanged deserializer");
        return false;
      }
      // A null |impl| means no implementation was bound.
      assert(impl);
      TRACE_EVENT0("mojom", "WindowTreeClient::OnWindowBoundsChanged");
      mojo::internal::MessageDispatchContext context(message);
      impl->OnWindowBoundsChanged(
std::move(p_window), 
std::move(p_old_bounds), 
std::move(p_new_bounds), 
std::move(p_local_surface_id));
      return true;
    }
    case internal::kWindowTreeClient_OnClientAreaChanged_Name: {
      internal::WindowTreeClient_OnClientAreaChanged_Params_Data* params =
          reinterpret_cast<internal::WindowTreeClient_OnClientAreaChanged_Params_Data*>(
              message->mutable_payload());
      
      mojo::internal::SerializationContext serialization_context;
      serialization_context.handles.Swap((message)->mutable_handles());
      serialization_context.associated_endpoint_handles.swap(
          *(message)->mutable_associated_endpoint_handles());
      bool success = true;
      uint32_t p_window_id{};
      ::gfx::mojom::blink::InsetsPtr p_new_client_area{};
      WTF::Vector<::gfx::mojom::blink::RectPtr> p_new_additional_client_areas{};
      WindowTreeClient_OnClientAreaChanged_ParamsDataView input_data_view(params, &serialization_context);
      
      p_window_id = input_data_view.window_id();
      if (!input_data_view.ReadNewClientArea(&p_new_client_area))
        success = false;
      if (!input_data_view.ReadNewAdditionalClientAreas(&p_new_additional_client_areas))
        success = false;
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            "WindowTreeClient::OnClientAreaChanged deserializer");
        return false;
      }
      // A null |impl| means no implementation was bound.
      assert(impl);
      TRACE_EVENT0("mojom", "WindowTreeClient::OnClientAreaChanged");
      mojo::internal::MessageDispatchContext context(message);
      impl->OnClientAreaChanged(
std::move(p_window_id), 
std::move(p_new_client_area), 
std::move(p_new_additional_client_areas));
      return true;
    }
    case internal::kWindowTreeClient_OnTransientWindowAdded_Name: {
      internal::WindowTreeClient_OnTransientWindowAdded_Params_Data* params =
          reinterpret_cast<internal::WindowTreeClient_OnTransientWindowAdded_Params_Data*>(
              message->mutable_payload());
      
      mojo::internal::SerializationContext serialization_context;
      serialization_context.handles.Swap((message)->mutable_handles());
      serialization_context.associated_endpoint_handles.swap(
          *(message)->mutable_associated_endpoint_handles());
      bool success = true;
      uint32_t p_window_id{};
      uint32_t p_transient_window_id{};
      WindowTreeClient_OnTransientWindowAdded_ParamsDataView input_data_view(params, &serialization_context);
      
      p_window_id = input_data_view.window_id();
      p_transient_window_id = input_data_view.transient_window_id();
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            "WindowTreeClient::OnTransientWindowAdded deserializer");
        return false;
      }
      // A null |impl| means no implementation was bound.
      assert(impl);
      TRACE_EVENT0("mojom", "WindowTreeClient::OnTransientWindowAdded");
      mojo::internal::MessageDispatchContext context(message);
      impl->OnTransientWindowAdded(
std::move(p_window_id), 
std::move(p_transient_window_id));
      return true;
    }
    case internal::kWindowTreeClient_OnTransientWindowRemoved_Name: {
      internal::WindowTreeClient_OnTransientWindowRemoved_Params_Data* params =
          reinterpret_cast<internal::WindowTreeClient_OnTransientWindowRemoved_Params_Data*>(
              message->mutable_payload());
      
      mojo::internal::SerializationContext serialization_context;
      serialization_context.handles.Swap((message)->mutable_handles());
      serialization_context.associated_endpoint_handles.swap(
          *(message)->mutable_associated_endpoint_handles());
      bool success = true;
      uint32_t p_window_id{};
      uint32_t p_transient_window_id{};
      WindowTreeClient_OnTransientWindowRemoved_ParamsDataView input_data_view(params, &serialization_context);
      
      p_window_id = input_data_view.window_id();
      p_transient_window_id = input_data_view.transient_window_id();
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            "WindowTreeClient::OnTransientWindowRemoved deserializer");
        return false;
      }
      // A null |impl| means no implementation was bound.
      assert(impl);
      TRACE_EVENT0("mojom", "WindowTreeClient::OnTransientWindowRemoved");
      mojo::internal::MessageDispatchContext context(message);
      impl->OnTransientWindowRemoved(
std::move(p_window_id), 
std::move(p_transient_window_id));
      return true;
    }
    case internal::kWindowTreeClient_OnWindowHierarchyChanged_Name: {
      internal::WindowTreeClient_OnWindowHierarchyChanged_Params_Data* params =
          reinterpret_cast<internal::WindowTreeClient_OnWindowHierarchyChanged_Params_Data*>(
              message->mutable_payload());
      
      mojo::internal::SerializationContext serialization_context;
      serialization_context.handles.Swap((message)->mutable_handles());
      serialization_context.associated_endpoint_handles.swap(
          *(message)->mutable_associated_endpoint_handles());
      bool success = true;
      uint32_t p_window{};
      uint32_t p_old_parent{};
      uint32_t p_new_parent{};
      WTF::Vector<::ui::mojom::blink::WindowDataPtr> p_windows{};
      WindowTreeClient_OnWindowHierarchyChanged_ParamsDataView input_data_view(params, &serialization_context);
      
      p_window = input_data_view.window();
      p_old_parent = input_data_view.old_parent();
      p_new_parent = input_data_view.new_parent();
      if (!input_data_view.ReadWindows(&p_windows))
        success = false;
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            "WindowTreeClient::OnWindowHierarchyChanged deserializer");
        return false;
      }
      // A null |impl| means no implementation was bound.
      assert(impl);
      TRACE_EVENT0("mojom", "WindowTreeClient::OnWindowHierarchyChanged");
      mojo::internal::MessageDispatchContext context(message);
      impl->OnWindowHierarchyChanged(
std::move(p_window), 
std::move(p_old_parent), 
std::move(p_new_parent), 
std::move(p_windows));
      return true;
    }
    case internal::kWindowTreeClient_OnWindowReordered_Name: {
      internal::WindowTreeClient_OnWindowReordered_Params_Data* params =
          reinterpret_cast<internal::WindowTreeClient_OnWindowReordered_Params_Data*>(
              message->mutable_payload());
      
      mojo::internal::SerializationContext serialization_context;
      serialization_context.handles.Swap((message)->mutable_handles());
      serialization_context.associated_endpoint_handles.swap(
          *(message)->mutable_associated_endpoint_handles());
      bool success = true;
      uint32_t p_window_id{};
      uint32_t p_relative_window_id{};
      ::ui::mojom::blink::OrderDirection p_direction{};
      WindowTreeClient_OnWindowReordered_ParamsDataView input_data_view(params, &serialization_context);
      
      p_window_id = input_data_view.window_id();
      p_relative_window_id = input_data_view.relative_window_id();
      if (!input_data_view.ReadDirection(&p_direction))
        success = false;
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            "WindowTreeClient::OnWindowReordered deserializer");
        return false;
      }
      // A null |impl| means no implementation was bound.
      assert(impl);
      TRACE_EVENT0("mojom", "WindowTreeClient::OnWindowReordered");
      mojo::internal::MessageDispatchContext context(message);
      impl->OnWindowReordered(
std::move(p_window_id), 
std::move(p_relative_window_id), 
std::move(p_direction));
      return true;
    }
    case internal::kWindowTreeClient_OnWindowDeleted_Name: {
      internal::WindowTreeClient_OnWindowDeleted_Params_Data* params =
          reinterpret_cast<internal::WindowTreeClient_OnWindowDeleted_Params_Data*>(
              message->mutable_payload());
      
      mojo::internal::SerializationContext serialization_context;
      serialization_context.handles.Swap((message)->mutable_handles());
      serialization_context.associated_endpoint_handles.swap(
          *(message)->mutable_associated_endpoint_handles());
      bool success = true;
      uint32_t p_window{};
      WindowTreeClient_OnWindowDeleted_ParamsDataView input_data_view(params, &serialization_context);
      
      p_window = input_data_view.window();
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            "WindowTreeClient::OnWindowDeleted deserializer");
        return false;
      }
      // A null |impl| means no implementation was bound.
      assert(impl);
      TRACE_EVENT0("mojom", "WindowTreeClient::OnWindowDeleted");
      mojo::internal::MessageDispatchContext context(message);
      impl->OnWindowDeleted(
std::move(p_window));
      return true;
    }
    case internal::kWindowTreeClient_OnWindowVisibilityChanged_Name: {
      internal::WindowTreeClient_OnWindowVisibilityChanged_Params_Data* params =
          reinterpret_cast<internal::WindowTreeClient_OnWindowVisibilityChanged_Params_Data*>(
              message->mutable_payload());
      
      mojo::internal::SerializationContext serialization_context;
      serialization_context.handles.Swap((message)->mutable_handles());
      serialization_context.associated_endpoint_handles.swap(
          *(message)->mutable_associated_endpoint_handles());
      bool success = true;
      uint32_t p_window{};
      bool p_visible{};
      WindowTreeClient_OnWindowVisibilityChanged_ParamsDataView input_data_view(params, &serialization_context);
      
      p_window = input_data_view.window();
      p_visible = input_data_view.visible();
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            "WindowTreeClient::OnWindowVisibilityChanged deserializer");
        return false;
      }
      // A null |impl| means no implementation was bound.
      assert(impl);
      TRACE_EVENT0("mojom", "WindowTreeClient::OnWindowVisibilityChanged");
      mojo::internal::MessageDispatchContext context(message);
      impl->OnWindowVisibilityChanged(
std::move(p_window), 
std::move(p_visible));
      return true;
    }
    case internal::kWindowTreeClient_OnWindowOpacityChanged_Name: {
      internal::WindowTreeClient_OnWindowOpacityChanged_Params_Data* params =
          reinterpret_cast<internal::WindowTreeClient_OnWindowOpacityChanged_Params_Data*>(
              message->mutable_payload());
      
      mojo::internal::SerializationContext serialization_context;
      serialization_context.handles.Swap((message)->mutable_handles());
      serialization_context.associated_endpoint_handles.swap(
          *(message)->mutable_associated_endpoint_handles());
      bool success = true;
      uint32_t p_window{};
      float p_old_opacity{};
      float p_new_opacity{};
      WindowTreeClient_OnWindowOpacityChanged_ParamsDataView input_data_view(params, &serialization_context);
      
      p_window = input_data_view.window();
      p_old_opacity = input_data_view.old_opacity();
      p_new_opacity = input_data_view.new_opacity();
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            "WindowTreeClient::OnWindowOpacityChanged deserializer");
        return false;
      }
      // A null |impl| means no implementation was bound.
      assert(impl);
      TRACE_EVENT0("mojom", "WindowTreeClient::OnWindowOpacityChanged");
      mojo::internal::MessageDispatchContext context(message);
      impl->OnWindowOpacityChanged(
std::move(p_window), 
std::move(p_old_opacity), 
std::move(p_new_opacity));
      return true;
    }
    case internal::kWindowTreeClient_OnWindowParentDrawnStateChanged_Name: {
      internal::WindowTreeClient_OnWindowParentDrawnStateChanged_Params_Data* params =
          reinterpret_cast<internal::WindowTreeClient_OnWindowParentDrawnStateChanged_Params_Data*>(
              message->mutable_payload());
      
      mojo::internal::SerializationContext serialization_context;
      serialization_context.handles.Swap((message)->mutable_handles());
      serialization_context.associated_endpoint_handles.swap(
          *(message)->mutable_associated_endpoint_handles());
      bool success = true;
      uint32_t p_window{};
      bool p_drawn{};
      WindowTreeClient_OnWindowParentDrawnStateChanged_ParamsDataView input_data_view(params, &serialization_context);
      
      p_window = input_data_view.window();
      p_drawn = input_data_view.drawn();
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            "WindowTreeClient::OnWindowParentDrawnStateChanged deserializer");
        return false;
      }
      // A null |impl| means no implementation was bound.
      assert(impl);
      TRACE_EVENT0("mojom", "WindowTreeClient::OnWindowParentDrawnStateChanged");
      mojo::internal::MessageDispatchContext context(message);
      impl->OnWindowParentDrawnStateChanged(
std::move(p_window), 
std::move(p_drawn));
      return true;
    }
    case internal::kWindowTreeClient_OnWindowSharedPropertyChanged_Name: {
      internal::WindowTreeClient_OnWindowSharedPropertyChanged_Params_Data* params =
          reinterpret_cast<internal::WindowTreeClient_OnWindowSharedPropertyChanged_Params_Data*>(
              message->mutable_payload());
      
      mojo::internal::SerializationContext serialization_context;
      serialization_context.handles.Swap((message)->mutable_handles());
      serialization_context.associated_endpoint_handles.swap(
          *(message)->mutable_associated_endpoint_handles());
      bool success = true;
      uint32_t p_window{};
      WTF::String p_name{};
      WTF::Optional<WTF::Vector<uint8_t>> p_new_data{};
      WindowTreeClient_OnWindowSharedPropertyChanged_ParamsDataView input_data_view(params, &serialization_context);
      
      p_window = input_data_view.window();
      if (!input_data_view.ReadName(&p_name))
        success = false;
      if (!input_data_view.ReadNewData(&p_new_data))
        success = false;
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            "WindowTreeClient::OnWindowSharedPropertyChanged deserializer");
        return false;
      }
      // A null |impl| means no implementation was bound.
      assert(impl);
      TRACE_EVENT0("mojom", "WindowTreeClient::OnWindowSharedPropertyChanged");
      mojo::internal::MessageDispatchContext context(message);
      impl->OnWindowSharedPropertyChanged(
std::move(p_window), 
std::move(p_name), 
std::move(p_new_data));
      return true;
    }
    case internal::kWindowTreeClient_OnWindowInputEvent_Name: {
      internal::WindowTreeClient_OnWindowInputEvent_Params_Data* params =
          reinterpret_cast<internal::WindowTreeClient_OnWindowInputEvent_Params_Data*>(
              message->mutable_payload());
      
      mojo::internal::SerializationContext serialization_context;
      serialization_context.handles.Swap((message)->mutable_handles());
      serialization_context.associated_endpoint_handles.swap(
          *(message)->mutable_associated_endpoint_handles());
      bool success = true;
      uint32_t p_event_id{};
      uint32_t p_window{};
      int64_t p_display_id{};
      ::ui::mojom::blink::EventPtr p_event{};
      bool p_matches_pointer_watcher{};
      WindowTreeClient_OnWindowInputEvent_ParamsDataView input_data_view(params, &serialization_context);
      
      p_event_id = input_data_view.event_id();
      p_window = input_data_view.window();
      p_display_id = input_data_view.display_id();
      if (!input_data_view.ReadEvent(&p_event))
        success = false;
      p_matches_pointer_watcher = input_data_view.matches_pointer_watcher();
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            "WindowTreeClient::OnWindowInputEvent deserializer");
        return false;
      }
      // A null |impl| means no implementation was bound.
      assert(impl);
      TRACE_EVENT0("mojom", "WindowTreeClient::OnWindowInputEvent");
      mojo::internal::MessageDispatchContext context(message);
      impl->OnWindowInputEvent(
std::move(p_event_id), 
std::move(p_window), 
std::move(p_display_id), 
std::move(p_event), 
std::move(p_matches_pointer_watcher));
      return true;
    }
    case internal::kWindowTreeClient_OnPointerEventObserved_Name: {
      internal::WindowTreeClient_OnPointerEventObserved_Params_Data* params =
          reinterpret_cast<internal::WindowTreeClient_OnPointerEventObserved_Params_Data*>(
              message->mutable_payload());
      
      mojo::internal::SerializationContext serialization_context;
      serialization_context.handles.Swap((message)->mutable_handles());
      serialization_context.associated_endpoint_handles.swap(
          *(message)->mutable_associated_endpoint_handles());
      bool success = true;
      ::ui::mojom::blink::EventPtr p_event{};
      uint32_t p_window_id{};
      int64_t p_display_id{};
      WindowTreeClient_OnPointerEventObserved_ParamsDataView input_data_view(params, &serialization_context);
      
      if (!input_data_view.ReadEvent(&p_event))
        success = false;
      p_window_id = input_data_view.window_id();
      p_display_id = input_data_view.display_id();
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            "WindowTreeClient::OnPointerEventObserved deserializer");
        return false;
      }
      // A null |impl| means no implementation was bound.
      assert(impl);
      TRACE_EVENT0("mojom", "WindowTreeClient::OnPointerEventObserved");
      mojo::internal::MessageDispatchContext context(message);
      impl->OnPointerEventObserved(
std::move(p_event), 
std::move(p_window_id), 
std::move(p_display_id));
      return true;
    }
    case internal::kWindowTreeClient_OnWindowFocused_Name: {
      internal::WindowTreeClient_OnWindowFocused_Params_Data* params =
          reinterpret_cast<internal::WindowTreeClient_OnWindowFocused_Params_Data*>(
              message->mutable_payload());
      
      mojo::internal::SerializationContext serialization_context;
      serialization_context.handles.Swap((message)->mutable_handles());
      serialization_context.associated_endpoint_handles.swap(
          *(message)->mutable_associated_endpoint_handles());
      bool success = true;
      uint32_t p_focused_window_id{};
      WindowTreeClient_OnWindowFocused_ParamsDataView input_data_view(params, &serialization_context);
      
      p_focused_window_id = input_data_view.focused_window_id();
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            "WindowTreeClient::OnWindowFocused deserializer");
        return false;
      }
      // A null |impl| means no implementation was bound.
      assert(impl);
      TRACE_EVENT0("mojom", "WindowTreeClient::OnWindowFocused");
      mojo::internal::MessageDispatchContext context(message);
      impl->OnWindowFocused(
std::move(p_focused_window_id));
      return true;
    }
    case internal::kWindowTreeClient_OnWindowCursorChanged_Name: {
      internal::WindowTreeClient_OnWindowCursorChanged_Params_Data* params =
          reinterpret_cast<internal::WindowTreeClient_OnWindowCursorChanged_Params_Data*>(
              message->mutable_payload());
      
      mojo::internal::SerializationContext serialization_context;
      serialization_context.handles.Swap((message)->mutable_handles());
      serialization_context.associated_endpoint_handles.swap(
          *(message)->mutable_associated_endpoint_handles());
      bool success = true;
      uint32_t p_window_id{};
      ::ui::mojom::blink::CursorDataPtr p_cursor{};
      WindowTreeClient_OnWindowCursorChanged_ParamsDataView input_data_view(params, &serialization_context);
      
      p_window_id = input_data_view.window_id();
      if (!input_data_view.ReadCursor(&p_cursor))
        success = false;
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            "WindowTreeClient::OnWindowCursorChanged deserializer");
        return false;
      }
      // A null |impl| means no implementation was bound.
      assert(impl);
      TRACE_EVENT0("mojom", "WindowTreeClient::OnWindowCursorChanged");
      mojo::internal::MessageDispatchContext context(message);
      impl->OnWindowCursorChanged(
std::move(p_window_id), 
std::move(p_cursor));
      return true;
    }
    case internal::kWindowTreeClient_OnWindowSurfaceChanged_Name: {
      internal::WindowTreeClient_OnWindowSurfaceChanged_Params_Data* params =
          reinterpret_cast<internal::WindowTreeClient_OnWindowSurfaceChanged_Params_Data*>(
              message->mutable_payload());
      
      mojo::internal::SerializationContext serialization_context;
      serialization_context.handles.Swap((message)->mutable_handles());
      serialization_context.associated_endpoint_handles.swap(
          *(message)->mutable_associated_endpoint_handles());
      bool success = true;
      uint32_t p_window_id{};
      cc::SurfaceInfo p_surface_info{};
      WindowTreeClient_OnWindowSurfaceChanged_ParamsDataView input_data_view(params, &serialization_context);
      
      p_window_id = input_data_view.window_id();
      if (!input_data_view.ReadSurfaceInfo(&p_surface_info))
        success = false;
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            "WindowTreeClient::OnWindowSurfaceChanged deserializer");
        return false;
      }
      // A null |impl| means no implementation was bound.
      assert(impl);
      TRACE_EVENT0("mojom", "WindowTreeClient::OnWindowSurfaceChanged");
      mojo::internal::MessageDispatchContext context(message);
      impl->OnWindowSurfaceChanged(
std::move(p_window_id), 
std::move(p_surface_info));
      return true;
    }
    case internal::kWindowTreeClient_OnDragDropStart_Name: {
      internal::WindowTreeClient_OnDragDropStart_Params_Data* params =
          reinterpret_cast<internal::WindowTreeClient_OnDragDropStart_Params_Data*>(
              message->mutable_payload());
      
      mojo::internal::SerializationContext serialization_context;
      serialization_context.handles.Swap((message)->mutable_handles());
      serialization_context.associated_endpoint_handles.swap(
          *(message)->mutable_associated_endpoint_handles());
      bool success = true;
      WTF::HashMap<WTF::String, WTF::Vector<uint8_t>> p_drag_data{};
      WindowTreeClient_OnDragDropStart_ParamsDataView input_data_view(params, &serialization_context);
      
      if (!input_data_view.ReadDragData(&p_drag_data))
        success = false;
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            "WindowTreeClient::OnDragDropStart deserializer");
        return false;
      }
      // A null |impl| means no implementation was bound.
      assert(impl);
      TRACE_EVENT0("mojom", "WindowTreeClient::OnDragDropStart");
      mojo::internal::MessageDispatchContext context(message);
      impl->OnDragDropStart(
std::move(p_drag_data));
      return true;
    }
    case internal::kWindowTreeClient_OnDragEnter_Name: {
      break;
    }
    case internal::kWindowTreeClient_OnDragOver_Name: {
      break;
    }
    case internal::kWindowTreeClient_OnDragLeave_Name: {
      internal::WindowTreeClient_OnDragLeave_Params_Data* params =
          reinterpret_cast<internal::WindowTreeClient_OnDragLeave_Params_Data*>(
              message->mutable_payload());
      
      mojo::internal::SerializationContext serialization_context;
      serialization_context.handles.Swap((message)->mutable_handles());
      serialization_context.associated_endpoint_handles.swap(
          *(message)->mutable_associated_endpoint_handles());
      bool success = true;
      uint32_t p_window{};
      WindowTreeClient_OnDragLeave_ParamsDataView input_data_view(params, &serialization_context);
      
      p_window = input_data_view.window();
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            "WindowTreeClient::OnDragLeave deserializer");
        return false;
      }
      // A null |impl| means no implementation was bound.
      assert(impl);
      TRACE_EVENT0("mojom", "WindowTreeClient::OnDragLeave");
      mojo::internal::MessageDispatchContext context(message);
      impl->OnDragLeave(
std::move(p_window));
      return true;
    }
    case internal::kWindowTreeClient_OnCompleteDrop_Name: {
      break;
    }
    case internal::kWindowTreeClient_OnPerformDragDropCompleted_Name: {
      internal::WindowTreeClient_OnPerformDragDropCompleted_Params_Data* params =
          reinterpret_cast<internal::WindowTreeClient_OnPerformDragDropCompleted_Params_Data*>(
              message->mutable_payload());
      
      mojo::internal::SerializationContext serialization_context;
      serialization_context.handles.Swap((message)->mutable_handles());
      serialization_context.associated_endpoint_handles.swap(
          *(message)->mutable_associated_endpoint_handles());
      bool success = true;
      uint32_t p_window{};
      bool p_success{};
      uint32_t p_action_taken{};
      WindowTreeClient_OnPerformDragDropCompleted_ParamsDataView input_data_view(params, &serialization_context);
      
      p_window = input_data_view.window();
      p_success = input_data_view.success();
      p_action_taken = input_data_view.action_taken();
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            "WindowTreeClient::OnPerformDragDropCompleted deserializer");
        return false;
      }
      // A null |impl| means no implementation was bound.
      assert(impl);
      TRACE_EVENT0("mojom", "WindowTreeClient::OnPerformDragDropCompleted");
      mojo::internal::MessageDispatchContext context(message);
      impl->OnPerformDragDropCompleted(
std::move(p_window), 
std::move(p_success), 
std::move(p_action_taken));
      return true;
    }
    case internal::kWindowTreeClient_OnDragDropDone_Name: {
      internal::WindowTreeClient_OnDragDropDone_Params_Data* params =
          reinterpret_cast<internal::WindowTreeClient_OnDragDropDone_Params_Data*>(
              message->mutable_payload());
      
      mojo::internal::SerializationContext serialization_context;
      serialization_context.handles.Swap((message)->mutable_handles());
      serialization_context.associated_endpoint_handles.swap(
          *(message)->mutable_associated_endpoint_handles());
      bool success = true;
      WindowTreeClient_OnDragDropDone_ParamsDataView input_data_view(params, &serialization_context);
      
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            "WindowTreeClient::OnDragDropDone deserializer");
        return false;
      }
      // A null |impl| means no implementation was bound.
      assert(impl);
      TRACE_EVENT0("mojom", "WindowTreeClient::OnDragDropDone");
      mojo::internal::MessageDispatchContext context(message);
      impl->OnDragDropDone();
      return true;
    }
    case internal::kWindowTreeClient_OnChangeCompleted_Name: {
      internal::WindowTreeClient_OnChangeCompleted_Params_Data* params =
          reinterpret_cast<internal::WindowTreeClient_OnChangeCompleted_Params_Data*>(
              message->mutable_payload());
      
      mojo::internal::SerializationContext serialization_context;
      serialization_context.handles.Swap((message)->mutable_handles());
      serialization_context.associated_endpoint_handles.swap(
          *(message)->mutable_associated_endpoint_handles());
      bool success = true;
      uint32_t p_change_id{};
      bool p_success{};
      WindowTreeClient_OnChangeCompleted_ParamsDataView input_data_view(params, &serialization_context);
      
      p_change_id = input_data_view.change_id();
      p_success = input_data_view.success();
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            "WindowTreeClient::OnChangeCompleted deserializer");
        return false;
      }
      // A null |impl| means no implementation was bound.
      assert(impl);
      TRACE_EVENT0("mojom", "WindowTreeClient::OnChangeCompleted");
      mojo::internal::MessageDispatchContext context(message);
      impl->OnChangeCompleted(
std::move(p_change_id), 
std::move(p_success));
      return true;
    }
    case internal::kWindowTreeClient_RequestClose_Name: {
      internal::WindowTreeClient_RequestClose_Params_Data* params =
          reinterpret_cast<internal::WindowTreeClient_RequestClose_Params_Data*>(
              message->mutable_payload());
      
      mojo::internal::SerializationContext serialization_context;
      serialization_context.handles.Swap((message)->mutable_handles());
      serialization_context.associated_endpoint_handles.swap(
          *(message)->mutable_associated_endpoint_handles());
      bool success = true;
      uint32_t p_window_id{};
      WindowTreeClient_RequestClose_ParamsDataView input_data_view(params, &serialization_context);
      
      p_window_id = input_data_view.window_id();
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            "WindowTreeClient::RequestClose deserializer");
        return false;
      }
      // A null |impl| means no implementation was bound.
      assert(impl);
      TRACE_EVENT0("mojom", "WindowTreeClient::RequestClose");
      mojo::internal::MessageDispatchContext context(message);
      impl->RequestClose(
std::move(p_window_id));
      return true;
    }
    case internal::kWindowTreeClient_GetWindowManager_Name: {
      internal::WindowTreeClient_GetWindowManager_Params_Data* params =
          reinterpret_cast<internal::WindowTreeClient_GetWindowManager_Params_Data*>(
              message->mutable_payload());
      
      mojo::internal::SerializationContext serialization_context;
      serialization_context.handles.Swap((message)->mutable_handles());
      serialization_context.associated_endpoint_handles.swap(
          *(message)->mutable_associated_endpoint_handles());
      bool success = true;
      ::ui::mojom::blink::WindowManagerAssociatedRequest p_internal{};
      WindowTreeClient_GetWindowManager_ParamsDataView input_data_view(params, &serialization_context);
      
      p_internal =
          input_data_view.TakeInternal<decltype(p_internal)>();
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            "WindowTreeClient::GetWindowManager deserializer");
        return false;
      }
      // A null |impl| means no implementation was bound.
      assert(impl);
      TRACE_EVENT0("mojom", "WindowTreeClient::GetWindowManager");
      mojo::internal::MessageDispatchContext context(message);
      impl->GetWindowManager(
std::move(p_internal));
      return true;
    }
  }
  return false;
}

// static
bool WindowTreeClientStubDispatch::AcceptWithResponder(
    WindowTreeClient* impl,
    mojo::Message* message,
    std::unique_ptr<mojo::MessageReceiverWithStatus> responder) {
  switch (message->header()->name) {
    case internal::kWindowTreeClient_OnEmbed_Name: {
      break;
    }
    case internal::kWindowTreeClient_OnEmbeddedAppDisconnected_Name: {
      break;
    }
    case internal::kWindowTreeClient_OnUnembed_Name: {
      break;
    }
    case internal::kWindowTreeClient_OnCaptureChanged_Name: {
      break;
    }
    case internal::kWindowTreeClient_OnFrameSinkIdAllocated_Name: {
      break;
    }
    case internal::kWindowTreeClient_OnTopLevelCreated_Name: {
      break;
    }
    case internal::kWindowTreeClient_OnWindowBoundsChanged_Name: {
      break;
    }
    case internal::kWindowTreeClient_OnClientAreaChanged_Name: {
      break;
    }
    case internal::kWindowTreeClient_OnTransientWindowAdded_Name: {
      break;
    }
    case internal::kWindowTreeClient_OnTransientWindowRemoved_Name: {
      break;
    }
    case internal::kWindowTreeClient_OnWindowHierarchyChanged_Name: {
      break;
    }
    case internal::kWindowTreeClient_OnWindowReordered_Name: {
      break;
    }
    case internal::kWindowTreeClient_OnWindowDeleted_Name: {
      break;
    }
    case internal::kWindowTreeClient_OnWindowVisibilityChanged_Name: {
      break;
    }
    case internal::kWindowTreeClient_OnWindowOpacityChanged_Name: {
      break;
    }
    case internal::kWindowTreeClient_OnWindowParentDrawnStateChanged_Name: {
      break;
    }
    case internal::kWindowTreeClient_OnWindowSharedPropertyChanged_Name: {
      break;
    }
    case internal::kWindowTreeClient_OnWindowInputEvent_Name: {
      break;
    }
    case internal::kWindowTreeClient_OnPointerEventObserved_Name: {
      break;
    }
    case internal::kWindowTreeClient_OnWindowFocused_Name: {
      break;
    }
    case internal::kWindowTreeClient_OnWindowCursorChanged_Name: {
      break;
    }
    case internal::kWindowTreeClient_OnWindowSurfaceChanged_Name: {
      break;
    }
    case internal::kWindowTreeClient_OnDragDropStart_Name: {
      break;
    }
    case internal::kWindowTreeClient_OnDragEnter_Name: {
      internal::WindowTreeClient_OnDragEnter_Params_Data* params =
          reinterpret_cast<internal::WindowTreeClient_OnDragEnter_Params_Data*>(
              message->mutable_payload());
      
      mojo::internal::SerializationContext serialization_context;
      serialization_context.handles.Swap((message)->mutable_handles());
      serialization_context.associated_endpoint_handles.swap(
          *(message)->mutable_associated_endpoint_handles());
      bool success = true;
      uint32_t p_window{};
      uint32_t p_key_state{};
      ::gfx::mojom::blink::PointPtr p_screen_position{};
      uint32_t p_effect_bitmask{};
      WindowTreeClient_OnDragEnter_ParamsDataView input_data_view(params, &serialization_context);
      
      p_window = input_data_view.window();
      p_key_state = input_data_view.key_state();
      if (!input_data_view.ReadScreenPosition(&p_screen_position))
        success = false;
      p_effect_bitmask = input_data_view.effect_bitmask();
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            "WindowTreeClient::OnDragEnter deserializer");
        return false;
      }
      WindowTreeClient::OnDragEnterCallback callback =
          WindowTreeClient_OnDragEnter_ProxyToResponder::CreateCallback(
              message->request_id(),
              message->has_flag(mojo::Message::kFlagIsSync),
              std::move(responder));
      // A null |impl| means no implementation was bound.
      assert(impl);
      TRACE_EVENT0("mojom", "WindowTreeClient::OnDragEnter");
      mojo::internal::MessageDispatchContext context(message);
      impl->OnDragEnter(
std::move(p_window), 
std::move(p_key_state), 
std::move(p_screen_position), 
std::move(p_effect_bitmask), std::move(callback));
      return true;
    }
    case internal::kWindowTreeClient_OnDragOver_Name: {
      internal::WindowTreeClient_OnDragOver_Params_Data* params =
          reinterpret_cast<internal::WindowTreeClient_OnDragOver_Params_Data*>(
              message->mutable_payload());
      
      mojo::internal::SerializationContext serialization_context;
      serialization_context.handles.Swap((message)->mutable_handles());
      serialization_context.associated_endpoint_handles.swap(
          *(message)->mutable_associated_endpoint_handles());
      bool success = true;
      uint32_t p_window{};
      uint32_t p_key_state{};
      ::gfx::mojom::blink::PointPtr p_screen_position{};
      uint32_t p_effect_bitmask{};
      WindowTreeClient_OnDragOver_ParamsDataView input_data_view(params, &serialization_context);
      
      p_window = input_data_view.window();
      p_key_state = input_data_view.key_state();
      if (!input_data_view.ReadScreenPosition(&p_screen_position))
        success = false;
      p_effect_bitmask = input_data_view.effect_bitmask();
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            "WindowTreeClient::OnDragOver deserializer");
        return false;
      }
      WindowTreeClient::OnDragOverCallback callback =
          WindowTreeClient_OnDragOver_ProxyToResponder::CreateCallback(
              message->request_id(),
              message->has_flag(mojo::Message::kFlagIsSync),
              std::move(responder));
      // A null |impl| means no implementation was bound.
      assert(impl);
      TRACE_EVENT0("mojom", "WindowTreeClient::OnDragOver");
      mojo::internal::MessageDispatchContext context(message);
      impl->OnDragOver(
std::move(p_window), 
std::move(p_key_state), 
std::move(p_screen_position), 
std::move(p_effect_bitmask), std::move(callback));
      return true;
    }
    case internal::kWindowTreeClient_OnDragLeave_Name: {
      break;
    }
    case internal::kWindowTreeClient_OnCompleteDrop_Name: {
      internal::WindowTreeClient_OnCompleteDrop_Params_Data* params =
          reinterpret_cast<internal::WindowTreeClient_OnCompleteDrop_Params_Data*>(
              message->mutable_payload());
      
      mojo::internal::SerializationContext serialization_context;
      serialization_context.handles.Swap((message)->mutable_handles());
      serialization_context.associated_endpoint_handles.swap(
          *(message)->mutable_associated_endpoint_handles());
      bool success = true;
      uint32_t p_window{};
      uint32_t p_key_state{};
      ::gfx::mojom::blink::PointPtr p_screen_position{};
      uint32_t p_effect_bitmask{};
      WindowTreeClient_OnCompleteDrop_ParamsDataView input_data_view(params, &serialization_context);
      
      p_window = input_data_view.window();
      p_key_state = input_data_view.key_state();
      if (!input_data_view.ReadScreenPosition(&p_screen_position))
        success = false;
      p_effect_bitmask = input_data_view.effect_bitmask();
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            "WindowTreeClient::OnCompleteDrop deserializer");
        return false;
      }
      WindowTreeClient::OnCompleteDropCallback callback =
          WindowTreeClient_OnCompleteDrop_ProxyToResponder::CreateCallback(
              message->request_id(),
              message->has_flag(mojo::Message::kFlagIsSync),
              std::move(responder));
      // A null |impl| means no implementation was bound.
      assert(impl);
      TRACE_EVENT0("mojom", "WindowTreeClient::OnCompleteDrop");
      mojo::internal::MessageDispatchContext context(message);
      impl->OnCompleteDrop(
std::move(p_window), 
std::move(p_key_state), 
std::move(p_screen_position), 
std::move(p_effect_bitmask), std::move(callback));
      return true;
    }
    case internal::kWindowTreeClient_OnPerformDragDropCompleted_Name: {
      break;
    }
    case internal::kWindowTreeClient_OnDragDropDone_Name: {
      break;
    }
    case internal::kWindowTreeClient_OnChangeCompleted_Name: {
      break;
    }
    case internal::kWindowTreeClient_RequestClose_Name: {
      break;
    }
    case internal::kWindowTreeClient_GetWindowManager_Name: {
      break;
    }
  }
  return false;
}

bool WindowTreeClientRequestValidator::Accept(mojo::Message* message) {
  if (mojo::internal::ControlMessageHandler::IsControlMessage(message))
    return true;

  mojo::internal::ValidationContext validation_context(
    message->payload(), message->payload_num_bytes(),
    message->handles()->size(), message->payload_num_interface_ids(), message,
    "WindowTreeClient RequestValidator");

  switch (message->header()->name) {
    case internal::kWindowTreeClient_OnEmbed_Name: {
      if (!mojo::internal::ValidateMessageIsRequestWithoutResponse(
              message, &validation_context)) {
        return false;
      }
      if (!mojo::internal::ValidateMessagePayload<
               internal::WindowTreeClient_OnEmbed_Params_Data>(
                  message, &validation_context)) {
        return false;
      }
      return true;
    }
    case internal::kWindowTreeClient_OnEmbeddedAppDisconnected_Name: {
      if (!mojo::internal::ValidateMessageIsRequestWithoutResponse(
              message, &validation_context)) {
        return false;
      }
      if (!mojo::internal::ValidateMessagePayload<
               internal::WindowTreeClient_OnEmbeddedAppDisconnected_Params_Data>(
                  message, &validation_context)) {
        return false;
      }
      return true;
    }
    case internal::kWindowTreeClient_OnUnembed_Name: {
      if (!mojo::internal::ValidateMessageIsRequestWithoutResponse(
              message, &validation_context)) {
        return false;
      }
      if (!mojo::internal::ValidateMessagePayload<
               internal::WindowTreeClient_OnUnembed_Params_Data>(
                  message, &validation_context)) {
        return false;
      }
      return true;
    }
    case internal::kWindowTreeClient_OnCaptureChanged_Name: {
      if (!mojo::internal::ValidateMessageIsRequestWithoutResponse(
              message, &validation_context)) {
        return false;
      }
      if (!mojo::internal::ValidateMessagePayload<
               internal::WindowTreeClient_OnCaptureChanged_Params_Data>(
                  message, &validation_context)) {
        return false;
      }
      return true;
    }
    case internal::kWindowTreeClient_OnFrameSinkIdAllocated_Name: {
      if (!mojo::internal::ValidateMessageIsRequestWithoutResponse(
              message, &validation_context)) {
        return false;
      }
      if (!mojo::internal::ValidateMessagePayload<
               internal::WindowTreeClient_OnFrameSinkIdAllocated_Params_Data>(
                  message, &validation_context)) {
        return false;
      }
      return true;
    }
    case internal::kWindowTreeClient_OnTopLevelCreated_Name: {
      if (!mojo::internal::ValidateMessageIsRequestWithoutResponse(
              message, &validation_context)) {
        return false;
      }
      if (!mojo::internal::ValidateMessagePayload<
               internal::WindowTreeClient_OnTopLevelCreated_Params_Data>(
                  message, &validation_context)) {
        return false;
      }
      return true;
    }
    case internal::kWindowTreeClient_OnWindowBoundsChanged_Name: {
      if (!mojo::internal::ValidateMessageIsRequestWithoutResponse(
              message, &validation_context)) {
        return false;
      }
      if (!mojo::internal::ValidateMessagePayload<
               internal::WindowTreeClient_OnWindowBoundsChanged_Params_Data>(
                  message, &validation_context)) {
        return false;
      }
      return true;
    }
    case internal::kWindowTreeClient_OnClientAreaChanged_Name: {
      if (!mojo::internal::ValidateMessageIsRequestWithoutResponse(
              message, &validation_context)) {
        return false;
      }
      if (!mojo::internal::ValidateMessagePayload<
               internal::WindowTreeClient_OnClientAreaChanged_Params_Data>(
                  message, &validation_context)) {
        return false;
      }
      return true;
    }
    case internal::kWindowTreeClient_OnTransientWindowAdded_Name: {
      if (!mojo::internal::ValidateMessageIsRequestWithoutResponse(
              message, &validation_context)) {
        return false;
      }
      if (!mojo::internal::ValidateMessagePayload<
               internal::WindowTreeClient_OnTransientWindowAdded_Params_Data>(
                  message, &validation_context)) {
        return false;
      }
      return true;
    }
    case internal::kWindowTreeClient_OnTransientWindowRemoved_Name: {
      if (!mojo::internal::ValidateMessageIsRequestWithoutResponse(
              message, &validation_context)) {
        return false;
      }
      if (!mojo::internal::ValidateMessagePayload<
               internal::WindowTreeClient_OnTransientWindowRemoved_Params_Data>(
                  message, &validation_context)) {
        return false;
      }
      return true;
    }
    case internal::kWindowTreeClient_OnWindowHierarchyChanged_Name: {
      if (!mojo::internal::ValidateMessageIsRequestWithoutResponse(
              message, &validation_context)) {
        return false;
      }
      if (!mojo::internal::ValidateMessagePayload<
               internal::WindowTreeClient_OnWindowHierarchyChanged_Params_Data>(
                  message, &validation_context)) {
        return false;
      }
      return true;
    }
    case internal::kWindowTreeClient_OnWindowReordered_Name: {
      if (!mojo::internal::ValidateMessageIsRequestWithoutResponse(
              message, &validation_context)) {
        return false;
      }
      if (!mojo::internal::ValidateMessagePayload<
               internal::WindowTreeClient_OnWindowReordered_Params_Data>(
                  message, &validation_context)) {
        return false;
      }
      return true;
    }
    case internal::kWindowTreeClient_OnWindowDeleted_Name: {
      if (!mojo::internal::ValidateMessageIsRequestWithoutResponse(
              message, &validation_context)) {
        return false;
      }
      if (!mojo::internal::ValidateMessagePayload<
               internal::WindowTreeClient_OnWindowDeleted_Params_Data>(
                  message, &validation_context)) {
        return false;
      }
      return true;
    }
    case internal::kWindowTreeClient_OnWindowVisibilityChanged_Name: {
      if (!mojo::internal::ValidateMessageIsRequestWithoutResponse(
              message, &validation_context)) {
        return false;
      }
      if (!mojo::internal::ValidateMessagePayload<
               internal::WindowTreeClient_OnWindowVisibilityChanged_Params_Data>(
                  message, &validation_context)) {
        return false;
      }
      return true;
    }
    case internal::kWindowTreeClient_OnWindowOpacityChanged_Name: {
      if (!mojo::internal::ValidateMessageIsRequestWithoutResponse(
              message, &validation_context)) {
        return false;
      }
      if (!mojo::internal::ValidateMessagePayload<
               internal::WindowTreeClient_OnWindowOpacityChanged_Params_Data>(
                  message, &validation_context)) {
        return false;
      }
      return true;
    }
    case internal::kWindowTreeClient_OnWindowParentDrawnStateChanged_Name: {
      if (!mojo::internal::ValidateMessageIsRequestWithoutResponse(
              message, &validation_context)) {
        return false;
      }
      if (!mojo::internal::ValidateMessagePayload<
               internal::WindowTreeClient_OnWindowParentDrawnStateChanged_Params_Data>(
                  message, &validation_context)) {
        return false;
      }
      return true;
    }
    case internal::kWindowTreeClient_OnWindowSharedPropertyChanged_Name: {
      if (!mojo::internal::ValidateMessageIsRequestWithoutResponse(
              message, &validation_context)) {
        return false;
      }
      if (!mojo::internal::ValidateMessagePayload<
               internal::WindowTreeClient_OnWindowSharedPropertyChanged_Params_Data>(
                  message, &validation_context)) {
        return false;
      }
      return true;
    }
    case internal::kWindowTreeClient_OnWindowInputEvent_Name: {
      if (!mojo::internal::ValidateMessageIsRequestWithoutResponse(
              message, &validation_context)) {
        return false;
      }
      if (!mojo::internal::ValidateMessagePayload<
               internal::WindowTreeClient_OnWindowInputEvent_Params_Data>(
                  message, &validation_context)) {
        return false;
      }
      return true;
    }
    case internal::kWindowTreeClient_OnPointerEventObserved_Name: {
      if (!mojo::internal::ValidateMessageIsRequestWithoutResponse(
              message, &validation_context)) {
        return false;
      }
      if (!mojo::internal::ValidateMessagePayload<
               internal::WindowTreeClient_OnPointerEventObserved_Params_Data>(
                  message, &validation_context)) {
        return false;
      }
      return true;
    }
    case internal::kWindowTreeClient_OnWindowFocused_Name: {
      if (!mojo::internal::ValidateMessageIsRequestWithoutResponse(
              message, &validation_context)) {
        return false;
      }
      if (!mojo::internal::ValidateMessagePayload<
               internal::WindowTreeClient_OnWindowFocused_Params_Data>(
                  message, &validation_context)) {
        return false;
      }
      return true;
    }
    case internal::kWindowTreeClient_OnWindowCursorChanged_Name: {
      if (!mojo::internal::ValidateMessageIsRequestWithoutResponse(
              message, &validation_context)) {
        return false;
      }
      if (!mojo::internal::ValidateMessagePayload<
               internal::WindowTreeClient_OnWindowCursorChanged_Params_Data>(
                  message, &validation_context)) {
        return false;
      }
      return true;
    }
    case internal::kWindowTreeClient_OnWindowSurfaceChanged_Name: {
      if (!mojo::internal::ValidateMessageIsRequestWithoutResponse(
              message, &validation_context)) {
        return false;
      }
      if (!mojo::internal::ValidateMessagePayload<
               internal::WindowTreeClient_OnWindowSurfaceChanged_Params_Data>(
                  message, &validation_context)) {
        return false;
      }
      return true;
    }
    case internal::kWindowTreeClient_OnDragDropStart_Name: {
      if (!mojo::internal::ValidateMessageIsRequestWithoutResponse(
              message, &validation_context)) {
        return false;
      }
      if (!mojo::internal::ValidateMessagePayload<
               internal::WindowTreeClient_OnDragDropStart_Params_Data>(
                  message, &validation_context)) {
        return false;
      }
      return true;
    }
    case internal::kWindowTreeClient_OnDragEnter_Name: {
      if (!mojo::internal::ValidateMessageIsRequestExpectingResponse(
              message, &validation_context)) {
        return false;
      }
      if (!mojo::internal::ValidateMessagePayload<
               internal::WindowTreeClient_OnDragEnter_Params_Data>(
                  message, &validation_context)) {
        return false;
      }
      return true;
    }
    case internal::kWindowTreeClient_OnDragOver_Name: {
      if (!mojo::internal::ValidateMessageIsRequestExpectingResponse(
              message, &validation_context)) {
        return false;
      }
      if (!mojo::internal::ValidateMessagePayload<
               internal::WindowTreeClient_OnDragOver_Params_Data>(
                  message, &validation_context)) {
        return false;
      }
      return true;
    }
    case internal::kWindowTreeClient_OnDragLeave_Name: {
      if (!mojo::internal::ValidateMessageIsRequestWithoutResponse(
              message, &validation_context)) {
        return false;
      }
      if (!mojo::internal::ValidateMessagePayload<
               internal::WindowTreeClient_OnDragLeave_Params_Data>(
                  message, &validation_context)) {
        return false;
      }
      return true;
    }
    case internal::kWindowTreeClient_OnCompleteDrop_Name: {
      if (!mojo::internal::ValidateMessageIsRequestExpectingResponse(
              message, &validation_context)) {
        return false;
      }
      if (!mojo::internal::ValidateMessagePayload<
               internal::WindowTreeClient_OnCompleteDrop_Params_Data>(
                  message, &validation_context)) {
        return false;
      }
      return true;
    }
    case internal::kWindowTreeClient_OnPerformDragDropCompleted_Name: {
      if (!mojo::internal::ValidateMessageIsRequestWithoutResponse(
              message, &validation_context)) {
        return false;
      }
      if (!mojo::internal::ValidateMessagePayload<
               internal::WindowTreeClient_OnPerformDragDropCompleted_Params_Data>(
                  message, &validation_context)) {
        return false;
      }
      return true;
    }
    case internal::kWindowTreeClient_OnDragDropDone_Name: {
      if (!mojo::internal::ValidateMessageIsRequestWithoutResponse(
              message, &validation_context)) {
        return false;
      }
      if (!mojo::internal::ValidateMessagePayload<
               internal::WindowTreeClient_OnDragDropDone_Params_Data>(
                  message, &validation_context)) {
        return false;
      }
      return true;
    }
    case internal::kWindowTreeClient_OnChangeCompleted_Name: {
      if (!mojo::internal::ValidateMessageIsRequestWithoutResponse(
              message, &validation_context)) {
        return false;
      }
      if (!mojo::internal::ValidateMessagePayload<
               internal::WindowTreeClient_OnChangeCompleted_Params_Data>(
                  message, &validation_context)) {
        return false;
      }
      return true;
    }
    case internal::kWindowTreeClient_RequestClose_Name: {
      if (!mojo::internal::ValidateMessageIsRequestWithoutResponse(
              message, &validation_context)) {
        return false;
      }
      if (!mojo::internal::ValidateMessagePayload<
               internal::WindowTreeClient_RequestClose_Params_Data>(
                  message, &validation_context)) {
        return false;
      }
      return true;
    }
    case internal::kWindowTreeClient_GetWindowManager_Name: {
      if (!mojo::internal::ValidateMessageIsRequestWithoutResponse(
              message, &validation_context)) {
        return false;
      }
      if (!mojo::internal::ValidateMessagePayload<
               internal::WindowTreeClient_GetWindowManager_Params_Data>(
                  message, &validation_context)) {
        return false;
      }
      return true;
    }
    default:
      break;
  }

  // Unrecognized message.
  ReportValidationError(
      &validation_context,
      mojo::internal::VALIDATION_ERROR_MESSAGE_HEADER_UNKNOWN_METHOD);
  return false;
}

bool WindowTreeClientResponseValidator::Accept(mojo::Message* message) {
  if (mojo::internal::ControlMessageHandler::IsControlMessage(message))
    return true;

  mojo::internal::ValidationContext validation_context(
    message->payload(), message->payload_num_bytes(),
    message->handles()->size(), message->payload_num_interface_ids(), message,
    "WindowTreeClient ResponseValidator");

  if (!mojo::internal::ValidateMessageIsResponse(message, &validation_context))
    return false;
  switch (message->header()->name) {
    case internal::kWindowTreeClient_OnDragEnter_Name: {
      if (!mojo::internal::ValidateMessagePayload<
               internal::WindowTreeClient_OnDragEnter_ResponseParams_Data>(
                    message, &validation_context)) {
        return false;
      }
      return true;
    }
    case internal::kWindowTreeClient_OnDragOver_Name: {
      if (!mojo::internal::ValidateMessagePayload<
               internal::WindowTreeClient_OnDragOver_ResponseParams_Data>(
                    message, &validation_context)) {
        return false;
      }
      return true;
    }
    case internal::kWindowTreeClient_OnCompleteDrop_Name: {
      if (!mojo::internal::ValidateMessagePayload<
               internal::WindowTreeClient_OnCompleteDrop_ResponseParams_Data>(
                    message, &validation_context)) {
        return false;
      }
      return true;
    }
    default:
      break;
  }

  // Unrecognized message.
  ReportValidationError(
      &validation_context,
      mojo::internal::VALIDATION_ERROR_MESSAGE_HEADER_UNKNOWN_METHOD);
  return false;
}
const char WindowTreeFactory::Name_[] = "ui::mojom::WindowTreeFactory";

WindowTreeFactoryProxy::WindowTreeFactoryProxy(mojo::MessageReceiverWithResponder* receiver)
    : receiver_(receiver) {
}

void WindowTreeFactoryProxy::CreateWindowTree(
    WindowTreeRequest in_tree_request, WindowTreeClientPtr in_client) {
  mojo::internal::SerializationContext serialization_context;
  size_t size = sizeof(::ui::mojom::internal::WindowTreeFactory_CreateWindowTree_Params_Data);
  constexpr uint32_t kFlags = 0;
  mojo::internal::MessageBuilder builder(
      internal::kWindowTreeFactory_CreateWindowTree_Name, kFlags, size,
      serialization_context.associated_endpoint_count);

  auto params =
      ::ui::mojom::internal::WindowTreeFactory_CreateWindowTree_Params_Data::New(builder.buffer());
  ALLOW_UNUSED_LOCAL(params);
  mojo::internal::Serialize<::ui::mojom::WindowTreeRequestDataView>(
      in_tree_request, &params->tree_request, &serialization_context);
  MOJO_INTERNAL_DLOG_SERIALIZATION_WARNING(
      !mojo::internal::IsHandleOrInterfaceValid(params->tree_request),
      mojo::internal::VALIDATION_ERROR_UNEXPECTED_INVALID_HANDLE,
      "invalid tree_request in WindowTreeFactory.CreateWindowTree request");
  mojo::internal::Serialize<::ui::mojom::WindowTreeClientPtrDataView>(
      in_client, &params->client, &serialization_context);
  MOJO_INTERNAL_DLOG_SERIALIZATION_WARNING(
      !mojo::internal::IsHandleOrInterfaceValid(params->client),
      mojo::internal::VALIDATION_ERROR_UNEXPECTED_INVALID_HANDLE,
      "invalid client in WindowTreeFactory.CreateWindowTree request");
  (&serialization_context)->handles.Swap(
      builder.message()->mutable_handles());
  (&serialization_context)->associated_endpoint_handles.swap(
      *builder.message()->mutable_associated_endpoint_handles());
  // This return value may be ignored as false implies the Connector has
  // encountered an error, which will be visible through other means.
  ignore_result(receiver_->Accept(builder.message()));
}

// static
bool WindowTreeFactoryStubDispatch::Accept(
    WindowTreeFactory* impl,
    mojo::Message* message) {
  switch (message->header()->name) {
    case internal::kWindowTreeFactory_CreateWindowTree_Name: {
      internal::WindowTreeFactory_CreateWindowTree_Params_Data* params =
          reinterpret_cast<internal::WindowTreeFactory_CreateWindowTree_Params_Data*>(
              message->mutable_payload());
      
      mojo::internal::SerializationContext serialization_context;
      serialization_context.handles.Swap((message)->mutable_handles());
      serialization_context.associated_endpoint_handles.swap(
          *(message)->mutable_associated_endpoint_handles());
      bool success = true;
      WindowTreeRequest p_tree_request{};
      WindowTreeClientPtr p_client{};
      WindowTreeFactory_CreateWindowTree_ParamsDataView input_data_view(params, &serialization_context);
      
      p_tree_request =
          input_data_view.TakeTreeRequest<decltype(p_tree_request)>();
      p_client =
          input_data_view.TakeClient<decltype(p_client)>();
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            "WindowTreeFactory::CreateWindowTree deserializer");
        return false;
      }
      // A null |impl| means no implementation was bound.
      assert(impl);
      TRACE_EVENT0("mojom", "WindowTreeFactory::CreateWindowTree");
      mojo::internal::MessageDispatchContext context(message);
      impl->CreateWindowTree(
std::move(p_tree_request), 
std::move(p_client));
      return true;
    }
  }
  return false;
}

// static
bool WindowTreeFactoryStubDispatch::AcceptWithResponder(
    WindowTreeFactory* impl,
    mojo::Message* message,
    std::unique_ptr<mojo::MessageReceiverWithStatus> responder) {
  switch (message->header()->name) {
    case internal::kWindowTreeFactory_CreateWindowTree_Name: {
      break;
    }
  }
  return false;
}

bool WindowTreeFactoryRequestValidator::Accept(mojo::Message* message) {
  if (mojo::internal::ControlMessageHandler::IsControlMessage(message))
    return true;

  mojo::internal::ValidationContext validation_context(
    message->payload(), message->payload_num_bytes(),
    message->handles()->size(), message->payload_num_interface_ids(), message,
    "WindowTreeFactory RequestValidator");

  switch (message->header()->name) {
    case internal::kWindowTreeFactory_CreateWindowTree_Name: {
      if (!mojo::internal::ValidateMessageIsRequestWithoutResponse(
              message, &validation_context)) {
        return false;
      }
      if (!mojo::internal::ValidateMessagePayload<
               internal::WindowTreeFactory_CreateWindowTree_Params_Data>(
                  message, &validation_context)) {
        return false;
      }
      return true;
    }
    default:
      break;
  }

  // Unrecognized message.
  ReportValidationError(
      &validation_context,
      mojo::internal::VALIDATION_ERROR_MESSAGE_HEADER_UNKNOWN_METHOD);
  return false;
}

}  // namespace blink
}  // namespace mojom
}  // namespace ui

namespace mojo {

}  // namespace mojo

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